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


#define SWIG_VERSION 0x040300
#define SWIGPYTHON
#define SWIG_DIRECTORS
#define SWIG_PYTHON_THREADS
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#define SWIGPYTHON_FASTPROXY

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#if defined(__cplusplus) && __cplusplus >=201103L
# define SWIG_NULLPTR nullptr
#else
# define SWIG_NULLPTR NULL
#endif 

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

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


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

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

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

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

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

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

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

/* Note: Currently this won't activate - it is in place ready for when the
 * SWIGPYTHON_BUILTIN condition above gets removed. */
# if PY_VERSION_HEX < 0x030c0000 && defined(SWIGPYTHON_BUILTIN)
#  include <structmember.h>
#  define Py_READONLY READONLY
#  define Py_T_PYSSIZET T_PYSSIZET
# endif
#endif

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

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

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

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

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

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

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

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

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

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

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


/*
   Flags/methods for returning states.

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

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

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

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

   Now you can be more explicit:

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

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

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

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

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

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

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

       int food(double)
       int fooi(int);

   and you call

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

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

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

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

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

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


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#ifdef __cplusplus
}
#endif

/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define  SWIG_UnknownError    	   -1
#define  SWIG_IOError        	   -2
#define  SWIG_RuntimeError   	   -3
#define  SWIG_IndexError     	   -4
#define  SWIG_TypeError      	   -5
#define  SWIG_DivisionByZero 	   -6
#define  SWIG_OverflowError  	   -7
#define  SWIG_SyntaxError    	   -8
#define  SWIG_ValueError     	   -9
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12
#define  SWIG_NullReferenceError   -13


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

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

#endif

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

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


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

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

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

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

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

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

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

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


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

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

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

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

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

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

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

#ifdef __cplusplus
}
#endif


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

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

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

/* Common SWIG API */

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

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

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

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

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

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

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

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


/* Runtime API */

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

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


/* Runtime API implementation */

/* Error manipulation */

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

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

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

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

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

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

#else

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

#endif

/* Append a value to the result obj */

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

/* Unpack the argument tuple */

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

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

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

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

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

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

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

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

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

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

/* 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, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
  swig_varlinkobject *v = (swig_varlinkobject *) p;
  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
  if (gv) {
    size_t size = strlen(name)+1;
    gv->name = (char *)malloc(size);
    if (gv->name) {
      memcpy(gv->name, name, size);
      gv->get_attr = get_attr;
      gv->set_attr = set_attr;
      gv->next = v->vars;
    }
  }
  v->vars = gv;
}


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

#ifdef __cplusplus
}
#endif

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

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

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

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

#ifdef __cplusplus
extern "C" {
#endif

/* The python void return value */

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

/* SwigPyClientData */

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

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

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


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

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

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

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


#ifdef SWIGPYTHON_BUILTIN

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

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

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

#endif

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

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

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

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

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

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

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

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


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

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

SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
  PyTypeObject *target_tp = SwigPyObject_type();
  PyTypeObject *op_type = Py_TYPE(op);
#ifdef SWIGPYTHON_BUILTIN
  if (PyType_IsSubtype(op_type, target_tp))
    return 1;
  return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
#else
# ifdef Py_LIMITED_API
  int cmp;
  PyObject *tp_name;
#endif
  if (op_type == target_tp)
    return 1;
# ifdef Py_LIMITED_API
  tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
  if (!tp_name)
    return 0;
  cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyObject");
  SWIG_Py_DECREF(tp_name);
  return cmp == 0;
# else
  return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
# endif
#endif
}

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

static PyObject* Swig_Capsule_global = NULL;

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

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

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

      PyErr_Restore(type, value, traceback);

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

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

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

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

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

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

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

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

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      "SwigPyObject",                       /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /* tp_print */
#else
      (Py_ssize_t)0,                        /* tp_vectorcall_offset */
#endif
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyObject_repr,          /* tp_repr */
      &SwigPyObject_as_number,              /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      0,                                    /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      swigobject_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      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 */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                    /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                    /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    swigpyobject_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpyobject_type) != 0)
      return NULL;
  }
  return &swigpyobject_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyObject_dealloc },
    { Py_tp_repr, (void *)SwigPyObject_repr },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)swigobject_doc },
    { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
    { Py_tp_methods, (void *)swigobject_methods },
    { Py_nb_int, (void *)SwigPyObject_long },
    { 0, NULL }
  };
  PyType_Spec spec = {
    "SwigPyObject",
    sizeof(SwigPyObject),
    0,
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
    slots
  };
  return (PyTypeObject *)PyType_FromSpec(&spec);
#endif
}

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

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

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

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

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

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

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

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

SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
#ifdef Py_LIMITED_API
  int cmp;
  PyObject *tp_name;
#endif
  PyTypeObject* op_type = Py_TYPE(op);
  if (op_type == SwigPyPacked_TypeOnce())
    return 1;
#ifdef Py_LIMITED_API
  tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
  if (!tp_name)
    return 0;
  cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyPacked");
  SWIG_Py_DECREF(tp_name);
  return cmp == 0;
#else
  return (strcmp(op_type->tp_name, "SwigPyPacked") == 0);
#endif
}

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

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

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

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

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

static PyObject *Swig_This_global = NULL;

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

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

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

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

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

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

  obj = 0;

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

/* Acquire a pointer value */

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

/* Convert a pointer value */

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

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

  res = SWIG_ERROR;

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

/* Convert a function ptr value */

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

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

/* Convert a packed pointer value */

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

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

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

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

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


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

/* Create a new pointer object */

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

  if (!ptr)
    return SWIG_Py_Void();

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

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

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

/* Create a new packed object */

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

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

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

static PyObject *Swig_TypeCache_global = NULL;

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

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


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

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

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
 /* Add a dummy module object into sys.modules */
  PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
  PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && module) {
    if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
      ++interpreter_counter;
      Swig_Capsule_global = pointer;
    } else {
      SWIG_Py_DECREF(pointer);
    }
  } else {
    SWIG_Py_XDECREF(pointer);
  }
}

SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *key = SWIG_Python_str_FromChar(type); 
  PyObject *obj = PyDict_GetItem(cache, key);
  swig_type_info *descriptor;
  if (obj) {
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
      if (obj) {
        PyDict_SetItem(cache, key, obj);
        SWIG_Py_DECREF(obj);
      }
    }
  }
  SWIG_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);
      PyObject *bytes = NULL;
      const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
      const char *errmesg = tmp ? tmp : "Invalid error message";
      SWIG_Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, errmesg);
      } else {
	PyErr_Format(type, "%s %s", errmesg, mesg);
      }
      SWIG_Py_XDECREF(bytes);
      SWIG_Py_DECREF(old_str);
    }
    return 1;
  } else {
    return 0;
  }
}
  
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
  if (PyErr_Occurred()) {
    /* add information about failing argument */
    char mesg[256];
    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    return SWIG_Python_AddErrMesg(mesg, 1);
  } else {
    return 0;
  }
}

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

SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
  (void) obj;
  if (type) {
#if defined(SWIG_COBJECT_TYPES)
    if (obj && SwigPyObject_Check(obj)) {
      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
      if (otype) {
	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
		     type, otype);
	return;
      }
    } else 
#endif      
    {
#ifndef Py_LIMITED_API
      /* tp_name is not accessible */
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
      if (otype) {
	PyObject *str = PyObject_Str(obj);
	PyObject *bytes = NULL;
	const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 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);
	}
	SWIG_Py_XDECREF(bytes);
	SWIG_Py_XDECREF(str);
	return;
      }
#endif
    }   
    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
  } else {
    PyErr_Format(PyExc_TypeError, "unexpected type is received");
  }
}


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

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

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

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

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


#ifdef __cplusplus
}
#endif



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

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



#ifdef __cplusplus
extern "C" {
#endif

/* Method creation and docstring support functions */

SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name);
SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);

#ifdef __cplusplus
}
#endif


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

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

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

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

#ifdef SWIG_THREADS

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

#else /* __cplusplus */

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

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

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

#endif /* _WIN32 */

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

#endif /* __cplusplus */

#else /* SWIG_THREADS */

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

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

#ifndef SWIG_DIRECTOR_PYTHON_HEADER_
#define SWIG_DIRECTOR_PYTHON_HEADER_

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

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

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



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


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

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

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

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

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

#else

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

#endif /* SWIG_DIRECTOR_NORTTI */

extern "C" {
  struct swig_type_info;
}

namespace Swig {

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

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

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

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

    ~GCItem_var() {
      delete _item;
    }

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

  private:
    GCItem *_item;
  };

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

    virtual ~GCItem_Object() {
    }

    int get_own() const {
      return _own;
    }

  private:
    int _own;
  };

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

    virtual ~GCItem_T() {
      delete _ptr;
    }

  private:
    Type *_ptr;
  };

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

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

  private:
    Type *_ptr;
  };

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

    virtual ~DirectorException() throw() {
    }

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

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

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

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

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

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

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

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

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

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

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

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



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  SWIG_GUARD_DEFINITION(Director, swig_mutex_own);
}

#endif

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

#define SWIGTYPE_p_ApplVerID swig_types[0]
#define SWIGTYPE_p_Application swig_types[1]
#define SWIGTYPE_p_BeginString swig_types[2]
#define SWIGTYPE_p_DOMDocumentPtr swig_types[3]
#define SWIGTYPE_p_Data swig_types[4]
#define SWIGTYPE_p_DataDictionary swig_types[5]
#define SWIGTYPE_p_DataDictionaryProvider swig_types[6]
#define SWIGTYPE_p_Dictionaries swig_types[7]
#define SWIGTYPE_p_DoubleField swig_types[8]
#define SWIGTYPE_p_FIX__Acceptor swig_types[9]
#define SWIGTYPE_p_FIX__Application swig_types[10]
#define SWIGTYPE_p_FIX__BeginString swig_types[11]
#define SWIGTYPE_p_FIX__BoolField swig_types[12]
#define SWIGTYPE_p_FIX__CharField swig_types[13]
#define SWIGTYPE_p_FIX__CheckSumField swig_types[14]
#define SWIGTYPE_p_FIX__ConfigError swig_types[15]
#define SWIGTYPE_p_FIX__DataDictionary swig_types[16]
#define SWIGTYPE_p_FIX__DataDictionaryNotFound swig_types[17]
#define SWIGTYPE_p_FIX__DatabaseConnectionID swig_types[18]
#define SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t swig_types[19]
#define SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t swig_types[20]
#define SWIGTYPE_p_FIX__DateTime swig_types[21]
#define SWIGTYPE_p_FIX__Dictionary swig_types[22]
#define SWIGTYPE_p_FIX__DoNotSend swig_types[23]
#define SWIGTYPE_p_FIX__DoubleField swig_types[24]
#define SWIGTYPE_p_FIX__DuplicateFieldNumber swig_types[25]
#define SWIGTYPE_p_FIX__Exception swig_types[26]
#define SWIGTYPE_p_FIX__FieldBase swig_types[27]
#define SWIGTYPE_p_FIX__FieldConvertError swig_types[28]
#define SWIGTYPE_p_FIX__FieldMap swig_types[29]
#define SWIGTYPE_p_FIX__FieldNotFound swig_types[30]
#define SWIGTYPE_p_FIX__FileLog swig_types[31]
#define SWIGTYPE_p_FIX__FileLogFactory swig_types[32]
#define SWIGTYPE_p_FIX__FileStore swig_types[33]
#define SWIGTYPE_p_FIX__FileStoreFactory swig_types[34]
#define SWIGTYPE_p_FIX__Group swig_types[35]
#define SWIGTYPE_p_FIX__Header swig_types[36]
#define SWIGTYPE_p_FIX__IOException swig_types[37]
#define SWIGTYPE_p_FIX__IncorrectDataFormat swig_types[38]
#define SWIGTYPE_p_FIX__IncorrectMessageStructure swig_types[39]
#define SWIGTYPE_p_FIX__IncorrectTagValue swig_types[40]
#define SWIGTYPE_p_FIX__Initiator swig_types[41]
#define SWIGTYPE_p_FIX__Int64Field swig_types[42]
#define SWIGTYPE_p_FIX__IntField swig_types[43]
#define SWIGTYPE_p_FIX__InvalidMessage swig_types[44]
#define SWIGTYPE_p_FIX__InvalidMessageType swig_types[45]
#define SWIGTYPE_p_FIX__InvalidTagNumber swig_types[46]
#define SWIGTYPE_p_FIX__LocalDate swig_types[47]
#define SWIGTYPE_p_FIX__LocalTimeOnly swig_types[48]
#define SWIGTYPE_p_FIX__LocalTimeStamp swig_types[49]
#define SWIGTYPE_p_FIX__Log swig_types[50]
#define SWIGTYPE_p_FIX__LogFactory swig_types[51]
#define SWIGTYPE_p_FIX__MemoryStore swig_types[52]
#define SWIGTYPE_p_FIX__MemoryStoreFactory swig_types[53]
#define SWIGTYPE_p_FIX__Message swig_types[54]
#define SWIGTYPE_p_FIX__MessageParseError swig_types[55]
#define SWIGTYPE_p_FIX__MessageStore swig_types[56]
#define SWIGTYPE_p_FIX__MessageStoreExceptionWrapper swig_types[57]
#define SWIGTYPE_p_FIX__MessageStoreFactory swig_types[58]
#define SWIGTYPE_p_FIX__MessageStoreFactoryExceptionWrapper swig_types[59]
#define SWIGTYPE_p_FIX__MySQLConnection swig_types[60]
#define SWIGTYPE_p_FIX__MySQLLog swig_types[61]
#define SWIGTYPE_p_FIX__MySQLLogFactory swig_types[62]
#define SWIGTYPE_p_FIX__MySQLQuery swig_types[63]
#define SWIGTYPE_p_FIX__MySQLStore swig_types[64]
#define SWIGTYPE_p_FIX__MySQLStoreFactory swig_types[65]
#define SWIGTYPE_p_FIX__NoTagValue swig_types[66]
#define SWIGTYPE_p_FIX__NullApplication swig_types[67]
#define SWIGTYPE_p_FIX__NullLog swig_types[68]
#define SWIGTYPE_p_FIX__NullStore swig_types[69]
#define SWIGTYPE_p_FIX__NullStoreFactory swig_types[70]
#define SWIGTYPE_p_FIX__PostgreSQLConnection swig_types[71]
#define SWIGTYPE_p_FIX__PostgreSQLLog swig_types[72]
#define SWIGTYPE_p_FIX__PostgreSQLLogFactory swig_types[73]
#define SWIGTYPE_p_FIX__PostgreSQLQuery swig_types[74]
#define SWIGTYPE_p_FIX__PostgreSQLStore swig_types[75]
#define SWIGTYPE_p_FIX__PostgreSQLStoreFactory swig_types[76]
#define SWIGTYPE_p_FIX__RejectLogon swig_types[77]
#define SWIGTYPE_p_FIX__RepeatedTag swig_types[78]
#define SWIGTYPE_p_FIX__RepeatingGroupCountMismatch swig_types[79]
#define SWIGTYPE_p_FIX__RequiredTagMissing swig_types[80]
#define SWIGTYPE_p_FIX__RuntimeError swig_types[81]
#define SWIGTYPE_p_FIX__SSLSocketAcceptor swig_types[82]
#define SWIGTYPE_p_FIX__SSLSocketInitiator swig_types[83]
#define SWIGTYPE_p_FIX__ScreenLog swig_types[84]
#define SWIGTYPE_p_FIX__ScreenLogFactory swig_types[85]
#define SWIGTYPE_p_FIX__SenderCompID swig_types[86]
#define SWIGTYPE_p_FIX__Session swig_types[87]
#define SWIGTYPE_p_FIX__SessionID swig_types[88]
#define SWIGTYPE_p_FIX__SessionNotFound swig_types[89]
#define SWIGTYPE_p_FIX__SessionSettings swig_types[90]
#define SWIGTYPE_p_FIX__SocketAcceptor swig_types[91]
#define SWIGTYPE_p_FIX__SocketCloseFailed swig_types[92]
#define SWIGTYPE_p_FIX__SocketException swig_types[93]
#define SWIGTYPE_p_FIX__SocketInitiator swig_types[94]
#define SWIGTYPE_p_FIX__SocketRecvFailed swig_types[95]
#define SWIGTYPE_p_FIX__SocketSendFailed swig_types[96]
#define SWIGTYPE_p_FIX__StringField swig_types[97]
#define SWIGTYPE_p_FIX__SynchronizedApplication swig_types[98]
#define SWIGTYPE_p_FIX__TYPE__Type swig_types[99]
#define SWIGTYPE_p_FIX__TagNotDefinedForMessage swig_types[100]
#define SWIGTYPE_p_FIX__TagOutOfOrder swig_types[101]
#define SWIGTYPE_p_FIX__TargetCompID swig_types[102]
#define SWIGTYPE_p_FIX__ThreadedSocketAcceptor swig_types[103]
#define SWIGTYPE_p_FIX__ThreadedSocketInitiator swig_types[104]
#define SWIGTYPE_p_FIX__Trailer swig_types[105]
#define SWIGTYPE_p_FIX__UInt64Field swig_types[106]
#define SWIGTYPE_p_FIX__UnsupportedMessageType swig_types[107]
#define SWIGTYPE_p_FIX__UnsupportedVersion swig_types[108]
#define SWIGTYPE_p_FIX__UtcDate swig_types[109]
#define SWIGTYPE_p_FIX__UtcDateField swig_types[110]
#define SWIGTYPE_p_FIX__UtcTimeOnly swig_types[111]
#define SWIGTYPE_p_FIX__UtcTimeOnlyField swig_types[112]
#define SWIGTYPE_p_FIX__UtcTimeStamp swig_types[113]
#define SWIGTYPE_p_FIX__UtcTimeStampField swig_types[114]
#define SWIGTYPE_p_Fields swig_types[115]
#define SWIGTYPE_p_Group swig_types[116]
#define SWIGTYPE_p_Groups swig_types[117]
#define SWIGTYPE_p_IntArray swig_types[118]
#define SWIGTYPE_p_IntField swig_types[119]
#define SWIGTYPE_p_Log swig_types[120]
#define SWIGTYPE_p_LogFactory swig_types[121]
#define SWIGTYPE_p_MYSQL swig_types[122]
#define SWIGTYPE_p_MessageStore swig_types[123]
#define SWIGTYPE_p_MessageStoreFactory swig_types[124]
#define SWIGTYPE_p_MsgType swig_types[125]
#define SWIGTYPE_p_Mutex swig_types[126]
#define SWIGTYPE_p_PGconn swig_types[127]
#define SWIGTYPE_p_RSA swig_types[128]
#define SWIGTYPE_p_Responder swig_types[129]
#define SWIGTYPE_p_SessionID swig_types[130]
#define SWIGTYPE_p_SessionToPort swig_types[131]
#define SWIGTYPE_p_StringField swig_types[132]
#define SWIGTYPE_p_TimeRange swig_types[133]
#define SWIGTYPE_p_UtcDateField swig_types[134]
#define SWIGTYPE_p_X509 swig_types[135]
#define SWIGTYPE_p_allocator_type swig_types[136]
#define SWIGTYPE_p_bool swig_types[137]
#define SWIGTYPE_p_char swig_types[138]
#define SWIGTYPE_p_const_iterator swig_types[139]
#define SWIGTYPE_p_difference_type swig_types[140]
#define SWIGTYPE_p_double swig_types[141]
#define SWIGTYPE_p_g_const_iterator swig_types[142]
#define SWIGTYPE_p_g_iterator swig_types[143]
#define SWIGTYPE_p_g_value_type swig_types[144]
#define SWIGTYPE_p_int swig_types[145]
#define SWIGTYPE_p_iterator swig_types[146]
#define SWIGTYPE_p_key_type swig_types[147]
#define SWIGTYPE_p_long_long swig_types[148]
#define SWIGTYPE_p_message_order swig_types[149]
#define SWIGTYPE_p_p_FIX__DataDictionary swig_types[150]
#define SWIGTYPE_p_p_PyObject swig_types[151]
#define SWIGTYPE_p_short swig_types[152]
#define SWIGTYPE_p_signed_char swig_types[153]
#define SWIGTYPE_p_size_type swig_types[154]
#define SWIGTYPE_p_ssize_t swig_types[155]
#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[156]
#define SWIGTYPE_p_std__functionT_FIX__UtcTimeStamp_fF_t swig_types[157]
#define SWIGTYPE_p_std__invalid_argument swig_types[158]
#define SWIGTYPE_p_std__istream swig_types[159]
#define SWIGTYPE_p_std__lessT_FIX__SessionID_t swig_types[160]
#define SWIGTYPE_p_std__logic_error swig_types[161]
#define SWIGTYPE_p_std__mapT_FIX__SessionID_unsigned_short_t swig_types[162]
#define SWIGTYPE_p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t swig_types[163]
#define SWIGTYPE_p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__const_iterator swig_types[164]
#define SWIGTYPE_p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__iterator swig_types[165]
#define SWIGTYPE_p_std__mapT_std__string_std__string_t__const_iterator swig_types[166]
#define SWIGTYPE_p_std__ostream swig_types[167]
#define SWIGTYPE_p_std__setT_FIX__SessionID_t swig_types[168]
#define SWIGTYPE_p_std__setT_std__string_std__lessT_std__string_t_std__allocatorT_std__string_t_t swig_types[169]
#define SWIGTYPE_p_std__string swig_types[170]
#define SWIGTYPE_p_std__string__size_type swig_types[171]
#define SWIGTYPE_p_std__unique_ptrT_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t_t swig_types[172]
#define SWIGTYPE_p_std__unique_ptrT_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t_t swig_types[173]
#define SWIGTYPE_p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__const_iterator swig_types[174]
#define SWIGTYPE_p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__iterator swig_types[175]
#define SWIGTYPE_p_std__vectorT_std__string_t swig_types[176]
#define SWIGTYPE_p_swig__SwigPyIterator swig_types[177]
#define SWIGTYPE_p_time_t swig_types[178]
#define SWIGTYPE_p_tm swig_types[179]
#define SWIGTYPE_p_unsigned_char swig_types[180]
#define SWIGTYPE_p_unsigned_int swig_types[181]
#define SWIGTYPE_p_unsigned_long_long swig_types[182]
#define SWIGTYPE_p_unsigned_short swig_types[183]
#define SWIGTYPE_p_value_type swig_types[184]
static swig_type_info *swig_types[186];
static swig_module_info swig_module = {swig_types, 185, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

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

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

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

#else
#  define SWIG_init    init_quickfix

#endif

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

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

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

#endif


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


#include <stdexcept>


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

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

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

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


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


#include <string>


#include <iostream>

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


#include <typeinfo>
#include <stdexcept>


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


#include <stddef.h>


namespace swig {
  struct stop_iteration {
  };

  struct SwigPyIterator {
  private:
    SwigPtr_PyObject _seq;

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

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

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

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

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

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

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

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

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

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

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

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


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


#include <float.h>


#include <math.h>


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


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


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


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


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


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


  #define SWIG_From_long   PyInt_FromLong 


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


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


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


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


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


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


#include <algorithm>


#include <utility>


#include <set>


#include <vector>


#include <stdint.h>		// Use the C99 official header


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

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

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

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

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

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

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

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

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

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

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

}


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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

  };

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

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

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

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

  protected:
    out_iterator begin;
    out_iterator end;
  };

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

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


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

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

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

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

}


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


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

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

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


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 {
    PyErr_Clear();
    static swig_type_info *descriptor = SWIG_TypeQuery("std::string" " *");
    if (descriptor) {
      std::string *vptr;
      int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
      if (SWIG_IsOK(res) && val) *val = vptr;
      return res;
    }
  }
  return SWIG_ERROR;
}


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


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


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


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


#include <functional>

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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


      namespace swig {
	template <>  struct traits<std::vector< std::string, std::allocator< std::string > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::string" "," "std::allocator< std::string >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_string_Sg__iterator(std::vector< std::string > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_string_Sg____nonzero__(std::vector< std::string > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_string_Sg____bool__(std::vector< std::string > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::string >::size_type std_vector_Sl_std_string_Sg____len__(std::vector< std::string > const *self){
      return self->size();
    }

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


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


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

SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::string,std::allocator< std::string > >());
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_1(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j,std::vector< std::string,std::allocator< std::string > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_string_Sg____getitem____SWIG_1(std::vector< std::string > const *self,std::vector< std::string >::difference_type i){
      return *(swig::cgetpos(self, i));
    }

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

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

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

SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_2(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::string,std::allocator< std::string > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_string_Sg__append(std::vector< std::string > *self,std::vector< std::string >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator first,std::vector< std::string >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__insert__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_string_Sg__insert__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::size_type n,std::vector< std::string >::value_type const &x){ self->insert(pos, n, x); }

typedef int IntArray;

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

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


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 <Except.h>
#include <Exceptions.h>
#include <FieldTypes.h>
#include <Fields.h>
#include <FixFields.h>
#include <Message.h>
#include <Group.h>
#include <Field.h>
#include <FixCommonFields.h>
#include <Values.h>
#include <SessionID.h>
#include <Dictionary.h>
#include <SessionSettings.h>
#include <Session.h>
#include <Log.h>
#include <FileLog.h>
#include <MessageStore.h>
#include <FileStore.h>
#include <Application.h>
#include <Initiator.h>
#include <SocketInitiator.h>
#include <Acceptor.h>
#include <SocketAcceptor.h>
#include <DataDictionary.h>
#include <SocketMonitor.h>
#include <DatabaseConnectionID.h>
#include <DatabaseConnectionPool.h>
#include <ThreadedSocketAcceptor.h>
#include <ThreadedSocketInitiator.h>
#include <ThreadedSocketConnection.h>
#include <NullStore.h>

#ifdef HAVE_SSL
#include <SSLSocketAcceptor.h>
#include <SSLSocketInitiator.h>
#include <SSLSocketConnection.h>
#else
#include <SSLStubs.h>
#endif

#ifdef HAVE_MYSQL
#include <MySQLConnection.h>
#include <MySQLStore.h>
#include <MySQLLog.h>
#else
#include <MySQLStubs.h>
#endif

#ifdef HAVE_POSTGRESQL
#include <PostgreSQLConnection.h>
#include <PostgreSQLStore.h>
#include <PostgreSQLLog.h>
#else
#include <PostgreSQLStubs.h>
#endif

#include <functional>
#ifdef SWIGPYTHON
#include "datetime.h"
#endif

#ifdef SWIGPYTHON
template<typename Exception>
void raisePythonException(Exception const& e, swig_type_info* swigType)
{
  SWIG_Python_Raise(SWIG_NewPointerObj((new Exception(static_cast<const Exception&>(e))),swigType,SWIG_POINTER_OWN), typeid(Exception).name(), swigType);
}

bool tryPythonException(std::function<bool()> const& function)
{
  try
  {
    return function();
  }
  catch(FIX::DataDictionaryNotFound const& e)
  {
    raisePythonException<FIX::DataDictionaryNotFound>(e, SWIGTYPE_p_FIX__DataDictionaryNotFound); return false;
  }
  catch(FIX::FieldNotFound const& e)
  {
    raisePythonException<FIX::FieldNotFound>(e, SWIGTYPE_p_FIX__FieldNotFound); return false;
  }
  catch(FIX::FieldConvertError const& e)
  {
    raisePythonException<FIX::FieldConvertError>(e, SWIGTYPE_p_FIX__FieldConvertError); return false;
  }
  catch(FIX::MessageParseError const& e)
  {
    raisePythonException<FIX::MessageParseError>(e, SWIGTYPE_p_FIX__MessageParseError); return false;
  }
  catch(FIX::InvalidMessage const& e)
  {
    raisePythonException<FIX::InvalidMessage>(e, SWIGTYPE_p_FIX__InvalidMessage); return false;
  }
  catch(FIX::ConfigError const& e)
  {
    raisePythonException<FIX::ConfigError>(e, SWIGTYPE_p_FIX__ConfigError); return false;
  }
  catch(FIX::RuntimeError const& e)
  {
    raisePythonException<FIX::RuntimeError>(e, SWIGTYPE_p_FIX__RuntimeError); return false;
  }
  catch(FIX::InvalidTagNumber const& e)
  {
    raisePythonException<FIX::InvalidTagNumber>(e, SWIGTYPE_p_FIX__InvalidTagNumber); return false;
  }
  catch(FIX::RequiredTagMissing const& e)
  {
    raisePythonException<FIX::RequiredTagMissing>(e, SWIGTYPE_p_FIX__RequiredTagMissing); return false;
  }
  catch(FIX::TagNotDefinedForMessage const& e)
  {
    raisePythonException<FIX::TagNotDefinedForMessage>(e, SWIGTYPE_p_FIX__TagNotDefinedForMessage); return false;
  }
  catch(FIX::NoTagValue const& e)
  {
    raisePythonException<FIX::NoTagValue>(e, SWIGTYPE_p_FIX__NoTagValue); return false;
  }
  catch(FIX::IncorrectTagValue const& e)
  {
    raisePythonException<FIX::IncorrectTagValue>(e, SWIGTYPE_p_FIX__IncorrectTagValue); return false;
  }
  catch(FIX::IncorrectDataFormat const& e)
  {
    raisePythonException<FIX::IncorrectDataFormat>(e, SWIGTYPE_p_FIX__IncorrectDataFormat); return false;
  }
  catch(FIX::IncorrectMessageStructure const& e)
  {
    raisePythonException<FIX::IncorrectMessageStructure>(e, SWIGTYPE_p_FIX__IncorrectMessageStructure); return false;
  }
  catch(FIX::DuplicateFieldNumber const& e)
  {
    raisePythonException<FIX::DuplicateFieldNumber>(e, SWIGTYPE_p_FIX__DuplicateFieldNumber); return false;
  }
  catch(FIX::InvalidMessageType const& e)
  {
    raisePythonException<FIX::InvalidMessageType>(e, SWIGTYPE_p_FIX__InvalidMessageType); return false;
  }
  catch(FIX::UnsupportedMessageType const& e)
  {
    raisePythonException<FIX::UnsupportedMessageType>(e, SWIGTYPE_p_FIX__UnsupportedMessageType); return false;
  }
  catch(FIX::UnsupportedVersion const& e)
  {
    raisePythonException<FIX::UnsupportedVersion>(e, SWIGTYPE_p_FIX__UnsupportedVersion); return false;
  }
  catch(FIX::TagOutOfOrder const& e)
  {
    raisePythonException<FIX::TagOutOfOrder>(e, SWIGTYPE_p_FIX__TagOutOfOrder); return false;
  }
  catch(FIX::RepeatedTag const& e)
  {
    raisePythonException<FIX::RepeatedTag>(e, SWIGTYPE_p_FIX__RepeatedTag); return false;
  }
  catch(FIX::RepeatingGroupCountMismatch const& e)
  {
    raisePythonException<FIX::RepeatingGroupCountMismatch>(e, SWIGTYPE_p_FIX__RepeatingGroupCountMismatch); return false;
  }
  catch(FIX::DoNotSend const& e)
  {
    raisePythonException<FIX::DoNotSend>(e, SWIGTYPE_p_FIX__DoNotSend); return false;
  }
  catch(FIX::RejectLogon const& e)
  {
    raisePythonException<FIX::RejectLogon>(e, SWIGTYPE_p_FIX__RejectLogon); return false;
  }
  catch(FIX::SessionNotFound const& e)
  {
    raisePythonException<FIX::SessionNotFound>(e, SWIGTYPE_p_FIX__SessionNotFound); return false;
  }
  catch(FIX::IOException const& e)
  {
    raisePythonException<FIX::IOException>(e, SWIGTYPE_p_FIX__IOException); return false;
  }
  catch(FIX::SocketSendFailed const& e)
  {
    raisePythonException<FIX::SocketSendFailed>(e, SWIGTYPE_p_FIX__SocketSendFailed); return false;
  }
  catch(FIX::SocketRecvFailed const& e)
  {
    raisePythonException<FIX::SocketRecvFailed>(e, SWIGTYPE_p_FIX__SocketRecvFailed); return false;
  }
  catch(FIX::SocketCloseFailed const& e)
  {
    raisePythonException<FIX::SocketCloseFailed>(e, SWIGTYPE_p_FIX__SocketCloseFailed); return false;
  }
  catch(FIX::SocketException const& e)
  {
    raisePythonException<FIX::SocketException>(e, SWIGTYPE_p_FIX__SocketException); return false;
  }
  catch(FIX::Exception const& e)
  {
    raisePythonException<FIX::Exception>(e, SWIGTYPE_p_FIX__Exception); return false;
  }
  catch(std::exception const& e) 
  {
    SWIG_Error(SWIG_RuntimeError, e.what()); return false;
  }
  catch(...)
  {
    SWIG_Error(SWIG_RuntimeError, "unknown exception"); return false;
  }
}
#endif

#ifdef SWIGRUBY
template<typename Exception>
void raiseRubyException(Exception const& e, swig_type_info* swigType)
{
  rb_exc_raise(SWIG_Ruby_ExceptionType(swigType, SWIG_NewPointerObj((new Exception(static_cast<const Exception&>(e))),swigType,SWIG_POINTER_OWN)));
}

VALUE tryRubyException(std::function<VALUE()> const& function)
{
  try
  {
    return function();
  }
  catch(FIX::DataDictionaryNotFound const& e)
  {
    raiseRubyException<FIX::DataDictionaryNotFound>(e, SWIGTYPE_p_FIX__DataDictionaryNotFound); return Qnil;
  }
  catch(FIX::FieldNotFound const& e)
  {
    raiseRubyException<FIX::FieldNotFound>(e, SWIGTYPE_p_FIX__FieldNotFound); return Qnil;
  }
  catch(FIX::FieldConvertError const& e)
  {
    raiseRubyException<FIX::FieldConvertError>(e, SWIGTYPE_p_FIX__FieldConvertError); return Qnil;
  }
  catch(FIX::MessageParseError const& e)
  {
    raiseRubyException<FIX::MessageParseError>(e, SWIGTYPE_p_FIX__MessageParseError); return Qnil;
  }
  catch(FIX::InvalidMessage const& e)
  {
    raiseRubyException<FIX::InvalidMessage>(e, SWIGTYPE_p_FIX__InvalidMessage); return Qnil;
  }
  catch(FIX::ConfigError const& e)
  {
    raiseRubyException<FIX::ConfigError>(e, SWIGTYPE_p_FIX__ConfigError); return Qnil;
  }
  catch(FIX::RuntimeError const& e)
  {
    raiseRubyException<FIX::RuntimeError>(e, SWIGTYPE_p_FIX__RuntimeError); return Qnil;
  }
  catch(FIX::InvalidTagNumber const& e)
  {
    raiseRubyException<FIX::InvalidTagNumber>(e, SWIGTYPE_p_FIX__InvalidTagNumber); return Qnil;
  }
  catch(FIX::RequiredTagMissing const& e)
  {
    raiseRubyException<FIX::RequiredTagMissing>(e, SWIGTYPE_p_FIX__RequiredTagMissing); return Qnil;
  }
  catch(FIX::TagNotDefinedForMessage const& e)
  {
    raiseRubyException<FIX::TagNotDefinedForMessage>(e, SWIGTYPE_p_FIX__TagNotDefinedForMessage); return Qnil;
  }
  catch(FIX::NoTagValue const& e)
  {
    raiseRubyException<FIX::NoTagValue>(e, SWIGTYPE_p_FIX__NoTagValue); return Qnil;
  }
  catch(FIX::IncorrectTagValue const& e)
  {
    raiseRubyException<FIX::IncorrectTagValue>(e, SWIGTYPE_p_FIX__IncorrectTagValue); return Qnil;
  }
  catch(FIX::IncorrectDataFormat const& e)
  {
    raiseRubyException<FIX::IncorrectDataFormat>(e, SWIGTYPE_p_FIX__IncorrectDataFormat); return Qnil;
  }
  catch(FIX::IncorrectMessageStructure const& e)
  {
    raiseRubyException<FIX::IncorrectMessageStructure>(e, SWIGTYPE_p_FIX__IncorrectMessageStructure); return Qnil;
  }
  catch(FIX::DuplicateFieldNumber const& e)
  {
    raiseRubyException<FIX::DuplicateFieldNumber>(e, SWIGTYPE_p_FIX__DuplicateFieldNumber); return Qnil;
  }
  catch(FIX::InvalidMessageType const& e)
  {
    raiseRubyException<FIX::InvalidMessageType>(e, SWIGTYPE_p_FIX__InvalidMessageType); return Qnil;
  }
  catch(FIX::UnsupportedMessageType const& e)
  {
    raiseRubyException<FIX::UnsupportedMessageType>(e, SWIGTYPE_p_FIX__UnsupportedMessageType); return Qnil;
  }
  catch(FIX::UnsupportedVersion const& e)
  {
    raiseRubyException<FIX::UnsupportedVersion>(e, SWIGTYPE_p_FIX__UnsupportedVersion); return Qnil;
  }
  catch(FIX::TagOutOfOrder const& e)
  {
    raiseRubyException<FIX::TagOutOfOrder>(e, SWIGTYPE_p_FIX__TagOutOfOrder); return Qnil;
  }
  catch(FIX::RepeatedTag const& e)
  {
    raiseRubyException<FIX::RepeatedTag>(e, SWIGTYPE_p_FIX__RepeatedTag); return Qnil;
  }
  catch(FIX::RepeatingGroupCountMismatch const& e)
  {
    raiseRubyException<FIX::RepeatingGroupCountMismatch>(e, SWIGTYPE_p_FIX__RepeatingGroupCountMismatch); return Qnil;
  }
  catch(FIX::DoNotSend const& e)
  {
    raiseRubyException<FIX::DoNotSend>(e, SWIGTYPE_p_FIX__DoNotSend); return Qnil;
  }
  catch(FIX::RejectLogon const& e)
  {
    raiseRubyException<FIX::RejectLogon>(e, SWIGTYPE_p_FIX__RejectLogon); return Qnil;
  }
  catch(FIX::SessionNotFound const& e)
  {
    raiseRubyException<FIX::SessionNotFound>(e, SWIGTYPE_p_FIX__SessionNotFound); return Qnil;
  }
  catch(FIX::IOException const& e)
  {
    raiseRubyException<FIX::IOException>(e, SWIGTYPE_p_FIX__IOException); return Qnil;
  }
  catch(FIX::SocketSendFailed const& e)
  {
    raiseRubyException<FIX::SocketSendFailed>(e, SWIGTYPE_p_FIX__SocketSendFailed); return Qnil;
  }
  catch(FIX::SocketRecvFailed const& e)
  {
    raiseRubyException<FIX::SocketRecvFailed>(e, SWIGTYPE_p_FIX__SocketRecvFailed); return Qnil;
  }
  catch(FIX::SocketCloseFailed const& e)
  {
    raiseRubyException<FIX::SocketCloseFailed>(e, SWIGTYPE_p_FIX__SocketCloseFailed); return Qnil;
  }
  catch(FIX::SocketException const& e)
  {
    raiseRubyException<FIX::SocketException>(e, SWIGTYPE_p_FIX__SocketException); return Qnil;
  }
  catch(FIX::Exception const& e)
  {
    raiseRubyException<FIX::Exception>(e, SWIGTYPE_p_FIX__Exception); return Qnil;
  }
  catch(std::exception const& e) 
  {
    SWIG_Error(SWIG_RuntimeError, e.what()); return Qnil;
  }
  catch(...)
  {
    SWIG_Error(SWIG_RuntimeError, "unknown exception"); return Qnil;
  }
}
#endif
         
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;
typedef FIX::SessionSettings SessionSettings;


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


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

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


      namespace swig {
	template <>  struct traits<std::set< FIX::SessionID, std::less< FIX::SessionID >, std::allocator< FIX::SessionID > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::set<" "FIX::SessionID" "," "std::less< FIX::SessionID >" "," "std::allocator< FIX::SessionID >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_set_Sl_FIX_SessionID_Sg__iterator(std::set< FIX::SessionID > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_set_Sl_FIX_SessionID_Sg____nonzero__(std::set< FIX::SessionID > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_set_Sl_FIX_SessionID_Sg____bool__(std::set< FIX::SessionID > const *self){
      return !(self->empty());
    }
SWIGINTERN std::set< FIX::SessionID >::size_type std_set_Sl_FIX_SessionID_Sg____len__(std::set< FIX::SessionID > const *self){
      return self->size();
    }
SWIGINTERN void std_set_Sl_FIX_SessionID_Sg__append(std::set< FIX::SessionID > *self,std::set< FIX::SessionID >::value_type x){
       self->insert(x);
     }
SWIGINTERN bool std_set_Sl_FIX_SessionID_Sg____contains__(std::set< FIX::SessionID > *self,std::set< FIX::SessionID >::value_type x){
       return self->find(x) != self->end();
     }
SWIGINTERN std::set< FIX::SessionID >::value_type std_set_Sl_FIX_SessionID_Sg____getitem__(std::set< FIX::SessionID > const *self,std::set< FIX::SessionID >::difference_type i){
       return *(swig::cgetpos(self, i));
     }
SWIGINTERN void std_set_Sl_FIX_SessionID_Sg__add(std::set< FIX::SessionID > *self,std::set< FIX::SessionID >::value_type x){
       self->insert(x);
     }
SWIGINTERN void std_set_Sl_FIX_SessionID_Sg__discard(std::set< FIX::SessionID > *self,std::set< FIX::SessionID >::value_type x){
       self->erase(x);
     }
SWIGINTERN void std_set_Sl_FIX_SessionID_Sg__erase__SWIG_1(std::set< FIX::SessionID > *self,std::set< FIX::SessionID >::iterator pos){ self->erase(pos); }
SWIGINTERN void std_set_Sl_FIX_SessionID_Sg__erase__SWIG_2(std::set< FIX::SessionID > *self,std::set< FIX::SessionID >::iterator first,std::set< FIX::SessionID >::iterator last){ self->erase(first, last); }

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

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

SWIGINTERN PyObject *FIX_UtcTimeStamp_getDateTime(FIX::UtcTimeStamp *self){
      int y, m, d, h, mi, s, fs;
      self->getYMD(y, m, d);
      self->getHMS(h, mi, s, fs, 6);
      return PyDateTime_FromDateAndTime(y, m, d, h, mi, s, fs);
  }
SWIGINTERN std::string FIX_FieldBase___str__(FIX::FieldBase *self){
    return self->getFixString();
  }




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


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


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


  #define SWIG_From_double   PyFloat_FromDouble 


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


#include <memory>


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();
  }
SWIGINTERN void FIX_SessionSettings_setFromString(FIX::SessionSettings *self,std::string const &str){
        std::stringstream(str) >> (*self);
    }

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


SWIGINTERNINLINE PyObject *
SWIG_From_short  (short value)
{    
  return SWIG_From_long  (value);
}



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

#include "QuickfixPython.h"

SwigDirector_LogFactory::SwigDirector_LogFactory(PyObject *self): FIX::LogFactory(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((FIX::LogFactory *)this, this); 
}




SwigDirector_LogFactory::~SwigDirector_LogFactory() {
}

FIX::Log *SwigDirector_LogFactory::create() {
  FIX::Log *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LogFactory.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "create";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("create");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          PyObject *ptype, *pvalue, *ptraceback;
          PyErr_Fetch( &ptype, &pvalue, &ptraceback );
          PyErr_Restore( ptype, pvalue, ptraceback );
          PyErr_Print();
          Py_Exit(1);
        }
      }
    }
    swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_FIX__Log,  0  | SWIG_POINTER_DISOWN, &own);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""FIX::Log *""'");
    }
    c_result = reinterpret_cast< FIX::Log * >(swig_argp);
    swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (FIX::Log *) c_result;
}


FIX::Log *SwigDirector_LogFactory::create(FIX::SessionID const &arg0) {
  FIX::Log *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__SessionID,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LogFactory.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 1;
    const char *const swig_method_name = "create";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("create");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          PyObject *ptype, *pvalue, *ptraceback;
          PyErr_Fetch( &ptype, &pvalue, &ptraceback );
          PyErr_Restore( ptype, pvalue, ptraceback );
          PyErr_Print();
          Py_Exit(1);
        }
      }
    }
    swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_FIX__Log,  0  | SWIG_POINTER_DISOWN, &own);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""FIX::Log *""'");
    }
    c_result = reinterpret_cast< FIX::Log * >(swig_argp);
    swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (FIX::Log *) c_result;
}


void SwigDirector_LogFactory::destroy(FIX::Log *arg0) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_FIX__Log,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LogFactory.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 2;
    const char *const swig_method_name = "destroy";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("destroy");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          PyObject *ptype, *pvalue, *ptraceback;
          PyErr_Fetch( &ptype, &pvalue, &ptraceback );
          PyErr_Restore( ptype, pvalue, ptraceback );
          PyErr_Print();
          Py_Exit(1);
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


SwigDirector_Log::SwigDirector_Log(PyObject *self): FIX::Log(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((FIX::Log *)this, this); 
}




SwigDirector_Log::~SwigDirector_Log() {
}

void SwigDirector_Log::clear() {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Log.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "clear";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("clear");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          PyObject *ptype, *pvalue, *ptraceback;
          PyErr_Fetch( &ptype, &pvalue, &ptraceback );
          PyErr_Restore( ptype, pvalue, ptraceback );
          PyErr_Print();
          Py_Exit(1);
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


void SwigDirector_Log::backup() {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Log.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 1;
    const char *const swig_method_name = "backup";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("backup");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          PyObject *ptype, *pvalue, *ptraceback;
          PyErr_Fetch( &ptype, &pvalue, &ptraceback );
          PyErr_Restore( ptype, pvalue, ptraceback );
          PyErr_Print();
          Py_Exit(1);
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


void SwigDirector_Log::onIncoming(std::string const &arg0) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_std_string(static_cast< std::string >(arg0));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Log.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 2;
    const char *const swig_method_name = "onIncoming";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onIncoming");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          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_Log::onOutgoing(std::string const &arg0) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_std_string(static_cast< std::string >(arg0));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Log.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 3;
    const char *const swig_method_name = "onOutgoing";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onOutgoing");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          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_Log::onEvent(std::string const &arg0) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_std_string(static_cast< std::string >(arg0));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Log.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 4;
    const char *const swig_method_name = "onEvent";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onEvent");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          PyObject *ptype, *pvalue, *ptraceback;
          PyErr_Fetch( &ptype, &pvalue, &ptraceback );
          PyErr_Restore( ptype, pvalue, ptraceback );
          PyErr_Print();
          Py_Exit(1);
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


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




SwigDirector_Application::~SwigDirector_Application() {
}

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

SWIGINTERN PyObject *_wrap_VectorString_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_iterator" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (swig::SwigPyIterator *)std_vector_Sl_std_string_Sg__iterator(arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___nonzero__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)std_vector_Sl_std_string_Sg____nonzero__((std::vector< std::string > const *)arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___bool__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)std_vector_Sl_std_string_Sg____bool__((std::vector< std::string > const *)arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___len__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = std_vector_Sl_std_string_Sg____len__((std::vector< std::string > const *)arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VectorString___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___getslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString___getslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorString___getslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      try {
        {
          SWIG_PYTHON_THREAD_BEGIN_ALLOW;
              result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
              SWIG_PYTHON_THREAD_END_ALLOW;
            }
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
          } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorString___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      try {
        {
          SWIG_PYTHON_THREAD_BEGIN_ALLOW;
              std_vector_Sl_std_string_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
              SWIG_PYTHON_THREAD_END_ALLOW;
            }
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
          } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorString___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorString___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VectorString___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      try {
        {
          SWIG_PYTHON_THREAD_BEGIN_ALLOW;
              std_vector_Sl_std_string_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
              SWIG_PYTHON_THREAD_END_ALLOW;
            }
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
          } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VectorString___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorString___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::string,std::allocator< std::string > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorString___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorString___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type)\n"
    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorString___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VectorString___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___delslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString___delslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorString___delslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      try {
        {
          SWIG_PYTHON_THREAD_BEGIN_ALLOW;
              std_vector_Sl_std_string_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
              SWIG_PYTHON_THREAD_END_ALLOW;
            }
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
          } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___delitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString___delitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      try {
        {
          SWIG_PYTHON_THREAD_BEGIN_ALLOW;
              std_vector_Sl_std_string_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
              SWIG_PYTHON_THREAD_END_ALLOW;
            }
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
          } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___getitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    if(!tryPythonException([&]() mutable
        {
      try {
        {
          SWIG_PYTHON_THREAD_BEGIN_ALLOW;
              result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getitem____SWIG_0(arg1,arg2);
              SWIG_PYTHON_THREAD_END_ALLOW;
            }
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
          } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorString___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VectorString___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      try {
        {
          SWIG_PYTHON_THREAD_BEGIN_ALLOW;
              std_vector_Sl_std_string_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
              SWIG_PYTHON_THREAD_END_ALLOW;
            }
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
          } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    if(!tryPythonException([&]() mutable
        {
      try {
        {
          SWIG_PYTHON_THREAD_BEGIN_ALLOW;
              std_vector_Sl_std_string_Sg____setitem____SWIG_1(arg1,arg2);
              SWIG_PYTHON_THREAD_END_ALLOW;
            }
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
          } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___delitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    if(!tryPythonException([&]() mutable
        {
      try {
        {
          SWIG_PYTHON_THREAD_BEGIN_ALLOW;
              std_vector_Sl_std_string_Sg____delitem____SWIG_1(arg1,arg2);
              SWIG_PYTHON_THREAD_END_ALLOW;
            }
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
          } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VectorString___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorString___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorString___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorString___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__delitem__(std::vector< std::string >::difference_type)\n"
    "    std::vector< std::string >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorString___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::string >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___getitem__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString___getitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      try {
        {
          SWIG_PYTHON_THREAD_BEGIN_ALLOW;
              result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg____getitem____SWIG_1((std::vector< std::string > const *)arg1,SWIG_STD_MOVE(arg2));
              SWIG_PYTHON_THREAD_END_ALLOW;
            }
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VectorString___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorString___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorString___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorString___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__getitem__(PySliceObject *)\n"
    "    std::vector< std::string >::__getitem__(std::vector< std::string >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorString___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString___setitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorString___setitem__" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VectorString___setitem__" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      try {
        {
          SWIG_PYTHON_THREAD_BEGIN_ALLOW;
              std_vector_Sl_std_string_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::string const &)*arg3);
              SWIG_PYTHON_THREAD_END_ALLOW;
            }
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::vector< std::string >::value_type const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VectorString___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorString___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorString___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorString___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorString___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__setitem__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    std::vector< std::string >::__setitem__(PySliceObject *)\n"
    "    std::vector< std::string >::__setitem__(std::vector< std::string >::difference_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorString_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_pop" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      try {
        {
          SWIG_PYTHON_THREAD_BEGIN_ALLOW;
              result = std_vector_Sl_std_string_Sg__pop(arg1);
              SWIG_PYTHON_THREAD_END_ALLOW;
            }
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VectorString_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_append" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorString_append" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VectorString_append" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            std_vector_Sl_std_string_Sg__append(arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::vector< std::string >::value_type const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::vector< std::string > *)new std::vector< std::string >();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::string > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorString" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_VectorString" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_empty" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((std::vector< std::string > const *)arg1)->empty();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_size" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((std::vector< std::string > const *)arg1)->size();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VectorString_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_swap" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorString_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VectorString_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->swap(*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_begin" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->begin();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_end" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->end();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_rbegin" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->rbegin();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_rend" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->rend();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_clear" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->clear();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::string > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_get_allocator" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((std::vector< std::string > const *)arg1)->get_allocator();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::string >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorString__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorString" "', argument " "1"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::string >::size_type >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::vector< std::string > *)new std::vector< std::string >(SWIG_STD_MOVE(arg1));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_pop_back" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->pop_back();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_resize" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->resize(SWIG_STD_MOVE(arg2));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::string >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_erase" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = std_vector_Sl_std_string_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::string >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_erase" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_erase" "', argument " "3"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_erase" "', argument " "3"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = std_vector_Sl_std_string_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VectorString_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorString_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorString_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorString_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::erase(std::vector< std::string >::iterator)\n"
    "    std::vector< std::string >::erase(std::vector< std::string >::iterator,std::vector< std::string >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorString__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string >::size_type arg1 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::string > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorString" "', argument " "1"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::string >::size_type >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorString" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_VectorString" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::vector< std::string > *)new std::vector< std::string >(SWIG_STD_MOVE(arg1),(std::vector< std::string >::value_type const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::vector< std::string >::value_type const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorString", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VectorString__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorString__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorString__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VectorString__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::vector()\n"
    "    std::vector< std::string >::vector(std::vector< std::string > const &)\n"
    "    std::vector< std::string >::vector(std::vector< std::string >::size_type)\n"
    "    std::vector< std::string >::vector(std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorString_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VectorString_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_push_back" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorString_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VectorString_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::vector< std::string >::value_type const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_front" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->front();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_back" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->back();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VectorString_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_assign" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString_assign" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorString_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VectorString_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< std::string >::value_type const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::vector< std::string >::value_type const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_resize" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorString_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VectorString_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< std::string >::value_type const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::vector< std::string >::value_type const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VectorString_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorString_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorString_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorString_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::resize(std::vector< std::string >::size_type)\n"
    "    std::vector< std::string >::resize(std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorString_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::string >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_insert" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorString_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VectorString_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = std_vector_Sl_std_string_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::string const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  {
    if( std::string("std::vector< std::string >::value_type const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::size_type arg3 ;
  std::vector< std::string >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_insert" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorString_insert" "', argument " "3"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::size_type >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorString_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VectorString_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            std_vector_Sl_std_string_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::string const &)*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::vector< std::string >::value_type const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VectorString_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorString_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorString_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorString_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::insert(std::vector< std::string >::iterator,std::vector< std::string >::value_type const &)\n"
    "    std::vector< std::string >::insert(std::vector< std::string >::iterator,std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorString_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VectorString_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_reserve" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString_reserve" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->reserve(SWIG_STD_MOVE(arg2));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_capacity" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((std::vector< std::string > const *)arg1)->capacity();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorString" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_IntArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  IntArray *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (IntArray *)new_IntArray(SWIG_STD_MOVE(arg1));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IntArray, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IntArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IntArray *arg1 = (IntArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete_IntArray(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntArray___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IntArray *arg1 = (IntArray *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IntArray___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)IntArray___getitem__(arg1,SWIG_STD_MOVE(arg2));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntArray___setitem__(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IntArray___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            IntArray___setitem__(arg1,SWIG_STD_MOVE(arg2),arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntArray_cast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IntArray *arg1 = (IntArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int *)IntArray_cast(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntArray_frompointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  IntArray *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (IntArray *)IntArray_frompointer(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IntArray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SessionIDSet__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::less< FIX::SessionID > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::set< FIX::SessionID > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__lessT_FIX__SessionID_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SessionIDSet" "', argument " "1"" of type '" "std::less< FIX::SessionID > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SessionIDSet" "', argument " "1"" of type '" "std::less< FIX::SessionID > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< FIX::SessionID > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::set< FIX::SessionID > *)new std::set< FIX::SessionID >((std::less< FIX::SessionID > const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_FIX__SessionID_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_iterator" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (swig::SwigPyIterator *)std_set_Sl_FIX_SessionID_Sg__iterator(arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet___nonzero__" "', argument " "1"" of type '" "std::set< FIX::SessionID > const *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)std_set_Sl_FIX_SessionID_Sg____nonzero__((std::set< FIX::SessionID > const *)arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet___bool__" "', argument " "1"" of type '" "std::set< FIX::SessionID > const *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)std_set_Sl_FIX_SessionID_Sg____bool__((std::set< FIX::SessionID > const *)arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< FIX::SessionID >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet___len__" "', argument " "1"" of type '" "std::set< FIX::SessionID > const *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = std_set_Sl_FIX_SessionID_Sg____len__((std::set< FIX::SessionID > const *)arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionIDSet_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_append" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionIDSet_append" "', argument " "2"" of type '" "std::set< FIX::SessionID >::value_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SessionIDSet_append" "', argument " "2"" of type '" "std::set< FIX::SessionID >::value_type""'");
    } else {
      std::set< FIX::SessionID >::value_type * temp = reinterpret_cast< std::set< FIX::SessionID >::value_type * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            std_set_Sl_FIX_SessionID_Sg__append(arg1,SWIG_STD_MOVE(arg2));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet___contains__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionIDSet___contains__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet___contains__" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionIDSet___contains__" "', argument " "2"" of type '" "std::set< FIX::SessionID >::value_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SessionIDSet___contains__" "', argument " "2"" of type '" "std::set< FIX::SessionID >::value_type""'");
    } else {
      std::set< FIX::SessionID >::value_type * temp = reinterpret_cast< std::set< FIX::SessionID >::value_type * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)std_set_Sl_FIX_SessionID_Sg____contains__(arg1,SWIG_STD_MOVE(arg2));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::set< FIX::SessionID >::value_type result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionIDSet___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet___getitem__" "', argument " "1"" of type '" "std::set< FIX::SessionID > const *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SessionIDSet___getitem__" "', argument " "2"" of type '" "std::set< FIX::SessionID >::difference_type""'");
  } 
  arg2 = static_cast< std::set< FIX::SessionID >::difference_type >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      try {
        {
          SWIG_PYTHON_THREAD_BEGIN_ALLOW;
              result = std_set_Sl_FIX_SessionID_Sg____getitem__((std::set< FIX::SessionID > const *)arg1,SWIG_STD_MOVE(arg2));
              SWIG_PYTHON_THREAD_END_ALLOW;
            }
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::set< FIX::SessionID >::value_type(result)), SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionIDSet_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_add" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionIDSet_add" "', argument " "2"" of type '" "std::set< FIX::SessionID >::value_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SessionIDSet_add" "', argument " "2"" of type '" "std::set< FIX::SessionID >::value_type""'");
    } else {
      std::set< FIX::SessionID >::value_type * temp = reinterpret_cast< std::set< FIX::SessionID >::value_type * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            std_set_Sl_FIX_SessionID_Sg__add(arg1,SWIG_STD_MOVE(arg2));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_discard(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionIDSet_discard", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_discard" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionIDSet_discard" "', argument " "2"" of type '" "std::set< FIX::SessionID >::value_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SessionIDSet_discard" "', argument " "2"" of type '" "std::set< FIX::SessionID >::value_type""'");
    } else {
      std::set< FIX::SessionID >::value_type * temp = reinterpret_cast< std::set< FIX::SessionID >::value_type * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            std_set_Sl_FIX_SessionID_Sg__discard(arg1,SWIG_STD_MOVE(arg2));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionIDSet__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::set< FIX::SessionID > *)new std::set< FIX::SessionID >();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_FIX__SessionID_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionIDSet__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::set< FIX::SessionID > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *ptr = (std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SessionIDSet" "', argument " "1"" of type '" "std::set< FIX::SessionID > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SessionIDSet" "', argument " "1"" of type '" "std::set< FIX::SessionID > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::set< FIX::SessionID > *)new std::set< FIX::SessionID >((std::set< FIX::SessionID > const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_FIX__SessionID_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionIDSet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SessionIDSet", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SessionIDSet__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_FIX__SessionID_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SessionIDSet__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SessionIDSet__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SessionIDSet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::set< FIX::SessionID >::set(std::less< FIX::SessionID > const &)\n"
    "    std::set< FIX::SessionID >::set()\n"
    "    std::set< FIX::SessionID >::set(std::set< FIX::SessionID > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_empty" "', argument " "1"" of type '" "std::set< FIX::SessionID > const *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((std::set< FIX::SessionID > const *)arg1)->empty();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< FIX::SessionID >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_size" "', argument " "1"" of type '" "std::set< FIX::SessionID > const *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((std::set< FIX::SessionID > const *)arg1)->size();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_clear" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->clear();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionIDSet_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_swap" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__setT_FIX__SessionID_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionIDSet_swap" "', argument " "2"" of type '" "std::set< FIX::SessionID > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SessionIDSet_swap" "', argument " "2"" of type '" "std::set< FIX::SessionID > &""'"); 
  }
  arg2 = reinterpret_cast< std::set< FIX::SessionID > * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->swap(*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::set< FIX::SessionID >::size_type result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_erase" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionIDSet_erase" "', argument " "2"" of type '" "std::set< FIX::SessionID >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SessionIDSet_erase" "', argument " "2"" of type '" "std::set< FIX::SessionID >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< FIX::SessionID >::key_type * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->erase((std::set< FIX::SessionID >::key_type const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::set< FIX::SessionID >::size_type result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionIDSet_count", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_count" "', argument " "1"" of type '" "std::set< FIX::SessionID > const *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionIDSet_count" "', argument " "2"" of type '" "std::set< FIX::SessionID >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SessionIDSet_count" "', argument " "2"" of type '" "std::set< FIX::SessionID >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< FIX::SessionID >::key_type * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((std::set< FIX::SessionID > const *)arg1)->count((std::set< FIX::SessionID >::key_type const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< FIX::SessionID >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_begin" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->begin();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::set< FIX::SessionID >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< FIX::SessionID >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_end" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->end();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::set< FIX::SessionID >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< FIX::SessionID >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_rbegin" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->rbegin();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::set< FIX::SessionID >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< FIX::SessionID >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_rend" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->rend();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::set< FIX::SessionID >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_erase" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SessionIDSet_erase" "', argument " "2"" of type '" "std::set< FIX::SessionID >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::set< FIX::SessionID >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::set< FIX::SessionID >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SessionIDSet_erase" "', argument " "2"" of type '" "std::set< FIX::SessionID >::iterator""'");
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            std_set_Sl_FIX_SessionID_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_erase__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID >::iterator arg2 ;
  std::set< FIX::SessionID >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_erase" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SessionIDSet_erase" "', argument " "2"" of type '" "std::set< FIX::SessionID >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::set< FIX::SessionID >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::set< FIX::SessionID >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SessionIDSet_erase" "', argument " "2"" of type '" "std::set< FIX::SessionID >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SessionIDSet_erase" "', argument " "3"" of type '" "std::set< FIX::SessionID >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::set< FIX::SessionID >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::set< FIX::SessionID >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SessionIDSet_erase" "', argument " "3"" of type '" "std::set< FIX::SessionID >::iterator""'");
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            std_set_Sl_FIX_SessionID_Sg__erase__SWIG_2(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_SessionIDSet_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::set< FIX::SessionID >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionIDSet_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_find" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionIDSet_find" "', argument " "2"" of type '" "std::set< FIX::SessionID >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SessionIDSet_find" "', argument " "2"" of type '" "std::set< FIX::SessionID >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< FIX::SessionID >::key_type * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->find((std::set< FIX::SessionID >::key_type const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::set< FIX::SessionID >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::set< FIX::SessionID >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionIDSet_lower_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_lower_bound" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionIDSet_lower_bound" "', argument " "2"" of type '" "std::set< FIX::SessionID >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SessionIDSet_lower_bound" "', argument " "2"" of type '" "std::set< FIX::SessionID >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< FIX::SessionID >::key_type * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->lower_bound((std::set< FIX::SessionID >::key_type const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::set< FIX::SessionID >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::set< FIX::SessionID >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionIDSet_upper_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_upper_bound" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionIDSet_upper_bound" "', argument " "2"" of type '" "std::set< FIX::SessionID >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SessionIDSet_upper_bound" "', argument " "2"" of type '" "std::set< FIX::SessionID >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< FIX::SessionID >::key_type * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->upper_bound((std::set< FIX::SessionID >::key_type const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::set< FIX::SessionID >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_equal_range(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::pair< std::set< FIX::SessionID >::iterator,std::set< FIX::SessionID >::iterator > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionIDSet_equal_range", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_equal_range" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionIDSet_equal_range" "', argument " "2"" of type '" "std::set< FIX::SessionID >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SessionIDSet_equal_range" "', argument " "2"" of type '" "std::set< FIX::SessionID >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< FIX::SessionID >::key_type * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->equal_range((std::set< FIX::SessionID >::key_type const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = PyTuple_New(2);
  PyTuple_SetItem(resultobj,0,SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::pair< std::set< FIX::SessionID >::iterator,std::set< FIX::SessionID >::iterator > & >(result).first),
      swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));
  PyTuple_SetItem(resultobj,1,SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::pair< std::set< FIX::SessionID >::iterator,std::set< FIX::SessionID >::iterator > & >(result).second),
      swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionIDSet_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  std::set< FIX::SessionID >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::pair< std::set< FIX::SessionID >::iterator,bool > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionIDSet_insert", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionIDSet_insert" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionIDSet_insert" "', argument " "2"" of type '" "std::set< FIX::SessionID >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SessionIDSet_insert" "', argument " "2"" of type '" "std::set< FIX::SessionID >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< FIX::SessionID >::value_type * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->insert((std::set< FIX::SessionID >::value_type const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = PyTuple_New(2);
  PyTuple_SetItem(resultobj,0,SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::pair< std::set< FIX::SessionID >::iterator,bool > & >(result).first),
      swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));    
  PyTuple_SetItem(resultobj,1,SWIG_From_bool  (static_cast< const std::pair< std::set< FIX::SessionID >::iterator,bool > & >(result).second));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SessionIDSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_FIX__SessionID_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SessionIDSet" "', argument " "1"" of type '" "std::set< FIX::SessionID > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_FIXException(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  FIX::Exception *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_FIXException", 2, 2, swig_obj)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FIXException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FIXException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FIXException" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FIXException" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Exception *)new FIX::Exception((std::string const &)*arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FIXException(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Exception *arg1 = (FIX::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Exception, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FIXException" "', argument " "1"" of type '" "FIX::Exception *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FIXException_type_set(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FIXException_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIXException_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(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIXException_type_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "FIXException_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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_FIXException_detail_set(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FIXException_detail_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIXException_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(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIXException_detail_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "FIXException_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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_FIXException___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Exception *arg1 = (FIX::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIXException___str__" "', argument " "1"" of type '" "FIX::Exception *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX_Exception___str__(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_DataDictionaryNotFound__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  FIX::DataDictionaryNotFound *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_DataDictionaryNotFound" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DataDictionaryNotFound *)new FIX::DataDictionaryNotFound((std::string const &)*arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionaryNotFound__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::DataDictionaryNotFound *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_DataDictionaryNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DataDictionaryNotFound *)new FIX::DataDictionaryNotFound((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionaryNotFound(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DataDictionaryNotFound", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DataDictionaryNotFound__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DataDictionaryNotFound__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DataDictionaryNotFound'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DataDictionaryNotFound::DataDictionaryNotFound(std::string const &,std::string const &)\n"
    "    FIX::DataDictionaryNotFound::DataDictionaryNotFound(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DataDictionaryNotFound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionaryNotFound *arg1 = (FIX::DataDictionaryNotFound *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionaryNotFound_version_set(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionaryNotFound_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_FieldNotFound__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FIX::FieldNotFound *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_FieldNotFound" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldNotFound *)new FIX::FieldNotFound(arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldNotFound__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::FieldNotFound *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FieldNotFound" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldNotFound *)new FIX::FieldNotFound(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldNotFound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldNotFound__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::FieldNotFound *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldNotFound *)new FIX::FieldNotFound();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldNotFound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldNotFound(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FieldNotFound", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_FieldNotFound__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_FieldNotFound__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FieldNotFound__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FieldNotFound'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldNotFound::FieldNotFound(int,std::string const &)\n"
    "    FIX::FieldNotFound::FieldNotFound(int)\n"
    "    FIX::FieldNotFound::FieldNotFound()\n");
  return 0;
}


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


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


SWIGINTERN PyObject *_wrap_delete_FieldNotFound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldNotFound *arg1 = (FIX::FieldNotFound *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_FieldConvertError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::FieldConvertError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_FieldConvertError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldConvertError *)new FIX::FieldConvertError((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldConvertError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::FieldConvertError *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldConvertError *)new FIX::FieldConvertError();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldConvertError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldConvertError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FieldConvertError", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_FieldConvertError__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FieldConvertError__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FieldConvertError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldConvertError::FieldConvertError(std::string const &)\n"
    "    FIX::FieldConvertError::FieldConvertError()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FieldConvertError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldConvertError *arg1 = (FIX::FieldConvertError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_MessageParseError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::MessageParseError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_MessageParseError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MessageParseError *)new FIX::MessageParseError((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MessageParseError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::MessageParseError *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MessageParseError *)new FIX::MessageParseError();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageParseError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MessageParseError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MessageParseError", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MessageParseError__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MessageParseError__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MessageParseError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MessageParseError::MessageParseError(std::string const &)\n"
    "    FIX::MessageParseError::MessageParseError()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MessageParseError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageParseError *arg1 = (FIX::MessageParseError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_InvalidMessage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::InvalidMessage *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_InvalidMessage" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::InvalidMessage *)new FIX::InvalidMessage((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidMessage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::InvalidMessage *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::InvalidMessage *)new FIX::InvalidMessage();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InvalidMessage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidMessage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvalidMessage", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_InvalidMessage__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvalidMessage__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvalidMessage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InvalidMessage::InvalidMessage(std::string const &)\n"
    "    FIX::InvalidMessage::InvalidMessage()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidMessage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidMessage *arg1 = (FIX::InvalidMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ConfigError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::ConfigError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_ConfigError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::ConfigError *)new FIX::ConfigError((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfigError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::ConfigError *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::ConfigError *)new FIX::ConfigError();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfigError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfigError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConfigError", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ConfigError__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfigError__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConfigError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ConfigError::ConfigError(std::string const &)\n"
    "    FIX::ConfigError::ConfigError()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConfigError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfigError *arg1 = (FIX::ConfigError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_RuntimeError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::RuntimeError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_RuntimeError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::RuntimeError *)new FIX::RuntimeError((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RuntimeError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::RuntimeError *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::RuntimeError *)new FIX::RuntimeError();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RuntimeError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RuntimeError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RuntimeError", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RuntimeError__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RuntimeError__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RuntimeError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RuntimeError::RuntimeError(std::string const &)\n"
    "    FIX::RuntimeError::RuntimeError()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RuntimeError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RuntimeError *arg1 = (FIX::RuntimeError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_InvalidTagNumber__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FIX::InvalidTagNumber *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_InvalidTagNumber" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::InvalidTagNumber *)new FIX::InvalidTagNumber(arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidTagNumber__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::InvalidTagNumber *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InvalidTagNumber" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::InvalidTagNumber *)new FIX::InvalidTagNumber(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InvalidTagNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidTagNumber__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::InvalidTagNumber *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::InvalidTagNumber *)new FIX::InvalidTagNumber();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InvalidTagNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidTagNumber(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvalidTagNumber", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_InvalidTagNumber__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_InvalidTagNumber__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvalidTagNumber__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvalidTagNumber'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InvalidTagNumber::InvalidTagNumber(int,std::string const &)\n"
    "    FIX::InvalidTagNumber::InvalidTagNumber(int)\n"
    "    FIX::InvalidTagNumber::InvalidTagNumber()\n");
  return 0;
}


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


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


SWIGINTERN PyObject *_wrap_delete_InvalidTagNumber(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidTagNumber *arg1 = (FIX::InvalidTagNumber *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_RequiredTagMissing__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FIX::RequiredTagMissing *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_RequiredTagMissing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::RequiredTagMissing *)new FIX::RequiredTagMissing(arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RequiredTagMissing__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::RequiredTagMissing *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RequiredTagMissing" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::RequiredTagMissing *)new FIX::RequiredTagMissing(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RequiredTagMissing, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RequiredTagMissing__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::RequiredTagMissing *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::RequiredTagMissing *)new FIX::RequiredTagMissing();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RequiredTagMissing, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RequiredTagMissing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RequiredTagMissing", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RequiredTagMissing__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_RequiredTagMissing__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RequiredTagMissing__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RequiredTagMissing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RequiredTagMissing::RequiredTagMissing(int,std::string const &)\n"
    "    FIX::RequiredTagMissing::RequiredTagMissing(int)\n"
    "    FIX::RequiredTagMissing::RequiredTagMissing()\n");
  return 0;
}


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


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


SWIGINTERN PyObject *_wrap_delete_RequiredTagMissing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RequiredTagMissing *arg1 = (FIX::RequiredTagMissing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_TagNotDefinedForMessage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FIX::TagNotDefinedForMessage *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_TagNotDefinedForMessage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::TagNotDefinedForMessage *)new FIX::TagNotDefinedForMessage(arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagNotDefinedForMessage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::TagNotDefinedForMessage *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TagNotDefinedForMessage" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::TagNotDefinedForMessage *)new FIX::TagNotDefinedForMessage(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TagNotDefinedForMessage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagNotDefinedForMessage__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::TagNotDefinedForMessage *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::TagNotDefinedForMessage *)new FIX::TagNotDefinedForMessage();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TagNotDefinedForMessage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagNotDefinedForMessage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TagNotDefinedForMessage", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TagNotDefinedForMessage__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TagNotDefinedForMessage__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TagNotDefinedForMessage__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TagNotDefinedForMessage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TagNotDefinedForMessage::TagNotDefinedForMessage(int,std::string const &)\n"
    "    FIX::TagNotDefinedForMessage::TagNotDefinedForMessage(int)\n"
    "    FIX::TagNotDefinedForMessage::TagNotDefinedForMessage()\n");
  return 0;
}


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


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


SWIGINTERN PyObject *_wrap_delete_TagNotDefinedForMessage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TagNotDefinedForMessage *arg1 = (FIX::TagNotDefinedForMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_NoTagValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FIX::NoTagValue *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_NoTagValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::NoTagValue *)new FIX::NoTagValue(arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTagValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::NoTagValue *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NoTagValue" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::NoTagValue *)new FIX::NoTagValue(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTagValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTagValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::NoTagValue *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::NoTagValue *)new FIX::NoTagValue();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTagValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTagValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NoTagValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_NoTagValue__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_NoTagValue__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_NoTagValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NoTagValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoTagValue::NoTagValue(int,std::string const &)\n"
    "    FIX::NoTagValue::NoTagValue(int)\n"
    "    FIX::NoTagValue::NoTagValue()\n");
  return 0;
}


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


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


SWIGINTERN PyObject *_wrap_delete_NoTagValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTagValue *arg1 = (FIX::NoTagValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_IncorrectTagValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FIX::IncorrectTagValue *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_IncorrectTagValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::IncorrectTagValue *)new FIX::IncorrectTagValue(arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectTagValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::IncorrectTagValue *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IncorrectTagValue" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::IncorrectTagValue *)new FIX::IncorrectTagValue(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncorrectTagValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectTagValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::IncorrectTagValue *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::IncorrectTagValue *)new FIX::IncorrectTagValue();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncorrectTagValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectTagValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IncorrectTagValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_IncorrectTagValue__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_IncorrectTagValue__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_IncorrectTagValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IncorrectTagValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IncorrectTagValue::IncorrectTagValue(int,std::string const &)\n"
    "    FIX::IncorrectTagValue::IncorrectTagValue(int)\n"
    "    FIX::IncorrectTagValue::IncorrectTagValue()\n");
  return 0;
}


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


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


SWIGINTERN PyObject *_wrap_delete_IncorrectTagValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectTagValue *arg1 = (FIX::IncorrectTagValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_IncorrectDataFormat__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FIX::IncorrectDataFormat *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_IncorrectDataFormat" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::IncorrectDataFormat *)new FIX::IncorrectDataFormat(arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectDataFormat__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::IncorrectDataFormat *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IncorrectDataFormat" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::IncorrectDataFormat *)new FIX::IncorrectDataFormat(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectDataFormat__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::IncorrectDataFormat *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::IncorrectDataFormat *)new FIX::IncorrectDataFormat();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectDataFormat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IncorrectDataFormat", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_IncorrectDataFormat__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_IncorrectDataFormat__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_IncorrectDataFormat__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IncorrectDataFormat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IncorrectDataFormat::IncorrectDataFormat(int,std::string const &)\n"
    "    FIX::IncorrectDataFormat::IncorrectDataFormat(int)\n"
    "    FIX::IncorrectDataFormat::IncorrectDataFormat()\n");
  return 0;
}


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


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


SWIGINTERN PyObject *_wrap_delete_IncorrectDataFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectDataFormat *arg1 = (FIX::IncorrectDataFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_IncorrectMessageStructure__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::IncorrectMessageStructure *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_IncorrectMessageStructure" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::IncorrectMessageStructure *)new FIX::IncorrectMessageStructure((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectMessageStructure__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::IncorrectMessageStructure *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::IncorrectMessageStructure *)new FIX::IncorrectMessageStructure();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncorrectMessageStructure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectMessageStructure(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IncorrectMessageStructure", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_IncorrectMessageStructure__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IncorrectMessageStructure__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IncorrectMessageStructure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IncorrectMessageStructure::IncorrectMessageStructure(std::string const &)\n"
    "    FIX::IncorrectMessageStructure::IncorrectMessageStructure()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IncorrectMessageStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectMessageStructure *arg1 = (FIX::IncorrectMessageStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_DuplicateFieldNumber__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::DuplicateFieldNumber *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_DuplicateFieldNumber" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DuplicateFieldNumber *)new FIX::DuplicateFieldNumber((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplicateFieldNumber__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::DuplicateFieldNumber *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DuplicateFieldNumber *)new FIX::DuplicateFieldNumber();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DuplicateFieldNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplicateFieldNumber(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DuplicateFieldNumber", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DuplicateFieldNumber__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DuplicateFieldNumber__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DuplicateFieldNumber'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DuplicateFieldNumber::DuplicateFieldNumber(std::string const &)\n"
    "    FIX::DuplicateFieldNumber::DuplicateFieldNumber()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DuplicateFieldNumber(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DuplicateFieldNumber *arg1 = (FIX::DuplicateFieldNumber *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_InvalidMessageType__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::InvalidMessageType *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_InvalidMessageType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::InvalidMessageType *)new FIX::InvalidMessageType((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidMessageType__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::InvalidMessageType *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::InvalidMessageType *)new FIX::InvalidMessageType();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InvalidMessageType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidMessageType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvalidMessageType", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_InvalidMessageType__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvalidMessageType__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvalidMessageType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InvalidMessageType::InvalidMessageType(std::string const &)\n"
    "    FIX::InvalidMessageType::InvalidMessageType()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidMessageType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidMessageType *arg1 = (FIX::InvalidMessageType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UnsupportedMessageType__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::UnsupportedMessageType *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_UnsupportedMessageType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UnsupportedMessageType *)new FIX::UnsupportedMessageType((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsupportedMessageType__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::UnsupportedMessageType *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UnsupportedMessageType *)new FIX::UnsupportedMessageType();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnsupportedMessageType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsupportedMessageType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UnsupportedMessageType", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UnsupportedMessageType__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnsupportedMessageType__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UnsupportedMessageType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnsupportedMessageType::UnsupportedMessageType(std::string const &)\n"
    "    FIX::UnsupportedMessageType::UnsupportedMessageType()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnsupportedMessageType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnsupportedMessageType *arg1 = (FIX::UnsupportedMessageType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UnsupportedVersion__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::UnsupportedVersion *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_UnsupportedVersion" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UnsupportedVersion *)new FIX::UnsupportedVersion((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsupportedVersion__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::UnsupportedVersion *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UnsupportedVersion *)new FIX::UnsupportedVersion();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnsupportedVersion, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsupportedVersion(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UnsupportedVersion", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UnsupportedVersion__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnsupportedVersion__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UnsupportedVersion'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnsupportedVersion::UnsupportedVersion(std::string const &)\n"
    "    FIX::UnsupportedVersion::UnsupportedVersion()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnsupportedVersion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnsupportedVersion *arg1 = (FIX::UnsupportedVersion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_TagOutOfOrder__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FIX::TagOutOfOrder *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_TagOutOfOrder" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::TagOutOfOrder *)new FIX::TagOutOfOrder(arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagOutOfOrder__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::TagOutOfOrder *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TagOutOfOrder" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::TagOutOfOrder *)new FIX::TagOutOfOrder(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TagOutOfOrder, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagOutOfOrder__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::TagOutOfOrder *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::TagOutOfOrder *)new FIX::TagOutOfOrder();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TagOutOfOrder, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagOutOfOrder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TagOutOfOrder", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TagOutOfOrder__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TagOutOfOrder__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TagOutOfOrder__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TagOutOfOrder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TagOutOfOrder::TagOutOfOrder(int,std::string const &)\n"
    "    FIX::TagOutOfOrder::TagOutOfOrder(int)\n"
    "    FIX::TagOutOfOrder::TagOutOfOrder()\n");
  return 0;
}


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


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


SWIGINTERN PyObject *_wrap_delete_TagOutOfOrder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TagOutOfOrder *arg1 = (FIX::TagOutOfOrder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_RepeatedTag__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FIX::RepeatedTag *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_RepeatedTag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::RepeatedTag *)new FIX::RepeatedTag(arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatedTag__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::RepeatedTag *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RepeatedTag" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::RepeatedTag *)new FIX::RepeatedTag(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepeatedTag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatedTag__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::RepeatedTag *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::RepeatedTag *)new FIX::RepeatedTag();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepeatedTag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatedTag(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RepeatedTag", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RepeatedTag__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_RepeatedTag__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RepeatedTag__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RepeatedTag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RepeatedTag::RepeatedTag(int,std::string const &)\n"
    "    FIX::RepeatedTag::RepeatedTag(int)\n"
    "    FIX::RepeatedTag::RepeatedTag()\n");
  return 0;
}


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


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


SWIGINTERN PyObject *_wrap_delete_RepeatedTag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepeatedTag *arg1 = (FIX::RepeatedTag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_RepeatingGroupCountMismatch__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_RepeatingGroupCountMismatch" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::RepeatingGroupCountMismatch *)new FIX::RepeatingGroupCountMismatch(arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatingGroupCountMismatch__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RepeatingGroupCountMismatch" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::RepeatingGroupCountMismatch *)new FIX::RepeatingGroupCountMismatch(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepeatingGroupCountMismatch, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatingGroupCountMismatch__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::RepeatingGroupCountMismatch *)new FIX::RepeatingGroupCountMismatch();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepeatingGroupCountMismatch, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatingGroupCountMismatch(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RepeatingGroupCountMismatch", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RepeatingGroupCountMismatch__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_RepeatingGroupCountMismatch__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RepeatingGroupCountMismatch__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RepeatingGroupCountMismatch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RepeatingGroupCountMismatch::RepeatingGroupCountMismatch(int,std::string const &)\n"
    "    FIX::RepeatingGroupCountMismatch::RepeatingGroupCountMismatch(int)\n"
    "    FIX::RepeatingGroupCountMismatch::RepeatingGroupCountMismatch()\n");
  return 0;
}


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


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


SWIGINTERN PyObject *_wrap_delete_RepeatingGroupCountMismatch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepeatingGroupCountMismatch *arg1 = (FIX::RepeatingGroupCountMismatch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_DoNotSend__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::DoNotSend *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_DoNotSend" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DoNotSend *)new FIX::DoNotSend((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoNotSend__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::DoNotSend *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DoNotSend *)new FIX::DoNotSend();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DoNotSend, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoNotSend(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DoNotSend", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DoNotSend__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DoNotSend__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DoNotSend'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DoNotSend::DoNotSend(std::string const &)\n"
    "    FIX::DoNotSend::DoNotSend()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DoNotSend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DoNotSend *arg1 = (FIX::DoNotSend *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_RejectLogon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::RejectLogon *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_RejectLogon" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::RejectLogon *)new FIX::RejectLogon((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RejectLogon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::RejectLogon *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::RejectLogon *)new FIX::RejectLogon();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RejectLogon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RejectLogon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RejectLogon", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RejectLogon__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RejectLogon__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RejectLogon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RejectLogon::RejectLogon(std::string const &)\n"
    "    FIX::RejectLogon::RejectLogon()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RejectLogon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RejectLogon *arg1 = (FIX::RejectLogon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SessionNotFound__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::SessionNotFound *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_SessionNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SessionNotFound *)new FIX::SessionNotFound((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionNotFound__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::SessionNotFound *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SessionNotFound *)new FIX::SessionNotFound();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionNotFound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionNotFound(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SessionNotFound", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SessionNotFound__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SessionNotFound__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SessionNotFound'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SessionNotFound::SessionNotFound(std::string const &)\n"
    "    FIX::SessionNotFound::SessionNotFound()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SessionNotFound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionNotFound *arg1 = (FIX::SessionNotFound *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_IOException__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::IOException *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_IOException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::IOException *)new FIX::IOException((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOException__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::IOException *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::IOException *)new FIX::IOException();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOException, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOException(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IOException", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_IOException__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOException__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IOException'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IOException::IOException(std::string const &)\n"
    "    FIX::IOException::IOException()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IOException(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOException *arg1 = (FIX::IOException *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SocketException__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::SocketException *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SocketException *)new FIX::SocketException();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketException, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketException__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::SocketException *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SocketException *)new FIX::SocketException((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketException(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SocketException", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SocketException__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SocketException__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SocketException'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SocketException::SocketException()\n"
    "    FIX::SocketException::SocketException(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SocketException_errorToWhat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SocketException_errorToWhat", 0, 0, 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::SocketException::errorToWhat();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SocketException(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketException *arg1 = (FIX::SocketException *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SocketSendFailed__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::SocketSendFailed *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SocketSendFailed *)new FIX::SocketSendFailed();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketSendFailed, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketSendFailed__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::SocketSendFailed *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketSendFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SocketSendFailed *)new FIX::SocketSendFailed((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketSendFailed(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SocketSendFailed", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SocketSendFailed__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SocketSendFailed__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SocketSendFailed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SocketSendFailed::SocketSendFailed()\n"
    "    FIX::SocketSendFailed::SocketSendFailed(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SocketSendFailed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketSendFailed *arg1 = (FIX::SocketSendFailed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SocketRecvFailed__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ssize_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  FIX::SocketRecvFailed *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ssize_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SocketRecvFailed" "', argument " "1"" of type '" "ssize_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SocketRecvFailed" "', argument " "1"" of type '" "ssize_t""'");
    } else {
      ssize_t * temp = reinterpret_cast< ssize_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SocketRecvFailed *)new FIX::SocketRecvFailed(SWIG_STD_MOVE(arg1));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketRecvFailed, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketRecvFailed__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::SocketRecvFailed *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketRecvFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SocketRecvFailed *)new FIX::SocketRecvFailed((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketRecvFailed(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SocketRecvFailed", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ssize_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SocketRecvFailed__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SocketRecvFailed__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SocketRecvFailed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SocketRecvFailed::SocketRecvFailed(ssize_t)\n"
    "    FIX::SocketRecvFailed::SocketRecvFailed(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SocketRecvFailed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketRecvFailed *arg1 = (FIX::SocketRecvFailed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SocketCloseFailed__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::SocketCloseFailed *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SocketCloseFailed *)new FIX::SocketCloseFailed();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketCloseFailed, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketCloseFailed__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::SocketCloseFailed *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketCloseFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SocketCloseFailed *)new FIX::SocketCloseFailed((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketCloseFailed(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SocketCloseFailed", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SocketCloseFailed__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SocketCloseFailed__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SocketCloseFailed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SocketCloseFailed::SocketCloseFailed()\n"
    "    FIX::SocketCloseFailed::SocketCloseFailed(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SocketCloseFailed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketCloseFailed *arg1 = (FIX::SocketCloseFailed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

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


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


SWIGINTERN PyObject *_wrap_DateTime_m_date_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_m_date_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_m_date_set" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_m_date_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->m_date = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_m_date_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_m_date_get" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->m_date);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_m_time_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_m_time_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_m_time_set" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_m_time_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = static_cast< int64_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->m_time = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_m_time_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_m_time_get" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int64_t) ((arg1)->m_time);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateTime__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::DateTime *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DateTime *)new FIX::DateTime();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateTime__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int64_t arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  FIX::DateTime *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTime" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTime" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = static_cast< int64_t >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DateTime *)new FIX::DateTime(arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateTime__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  FIX::DateTime *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTime" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTime" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTime" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTime" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTime" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTime" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTime" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DateTime *)new FIX::DateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateTime__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  FIX::DateTime *result = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTime" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTime" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTime" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTime" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTime" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTime" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTime" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DateTime" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DateTime *)new FIX::DateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DateTime", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DateTime__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DateTime__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_DateTime__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_DateTime__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DateTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DateTime::DateTime()\n"
    "    FIX::DateTime::DateTime(int,int64_t)\n"
    "    FIX::DateTime::DateTime(int,int,int,int,int,int,int)\n"
    "    FIX::DateTime::DateTime(int,int,int,int,int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getYear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getYear" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::DateTime const *)arg1)->getYear();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getMonth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getMonth" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::DateTime const *)arg1)->getMonth();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getDay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getDay" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::DateTime const *)arg1)->getDay();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getDate" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::DateTime const *)arg1)->getDate();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getJulianDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getJulianDate" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::DateTime const *)arg1)->getJulianDate();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getHour(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getHour" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::DateTime const *)arg1)->getHour();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getMinute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getMinute" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::DateTime const *)arg1)->getMinute();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getSecond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getSecond" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::DateTime const *)arg1)->getSecond();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getMillisecond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getMillisecond" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::DateTime const *)arg1)->getMillisecond();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getMicrosecond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getMicrosecond" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::DateTime const *)arg1)->getMicrosecond();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getNanosecond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getNanosecond" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (unsigned int)((FIX::DateTime const *)arg1)->getNanosecond();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getFraction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_getFraction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getFraction" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_getFraction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::DateTime const *)arg1)->getFraction(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getWeekDay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getWeekDay" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::DateTime const *)arg1)->getWeekDay();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getTimeT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  time_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getTimeT" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::DateTime const *)arg1)->getTimeT();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new time_t(result)), SWIGTYPE_p_time_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_getTmUtc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  tm result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_getTmUtc" "', argument " "1"" of type '" "FIX::DateTime const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::DateTime const *)arg1)->getTmUtc();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new tm(result)), SWIGTYPE_p_tm, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_setYMD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_setYMD", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_setYMD" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_setYMD" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_setYMD" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_setYMD" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setYMD(arg2,arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_setHMS__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_setHMS" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_setHMS" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_setHMS" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_setHMS" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_setHMS" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setHMS(arg2,arg3,arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_setHMS__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_setHMS" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_setHMS" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_setHMS" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_setHMS" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_setHMS" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_setHMS" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setHMS(arg2,arg3,arg4,arg5,arg6);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_setHMS(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DateTime_setHMS", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DateTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_DateTime_setHMS__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DateTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_DateTime_setHMS__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DateTime_setHMS'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DateTime::setHMS(int,int,int,int)\n"
    "    FIX::DateTime::setHMS(int,int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DateTime_setHour(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_setHour", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_setHour" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_setHour" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setHour(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_setMinute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_setMinute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_setMinute" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_setMinute" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setMinute(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_setSecond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_setSecond", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_setSecond" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_setSecond" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setSecond(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_setMillisecond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_setMillisecond", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_setMillisecond" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_setMillisecond" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setMillisecond(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_setMicrosecond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_setMicrosecond", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_setMicrosecond" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_setMicrosecond" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setMicrosecond(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_setNanosecond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_setNanosecond", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_setNanosecond" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_setNanosecond" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNanosecond(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_setFraction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_setFraction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_setFraction" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_setFraction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_setFraction" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setFraction(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_clearDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_clearDate" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->clearDate();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_clearTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_clearTime" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->clearTime();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int arg2 ;
  int64_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  long long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_set" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_set" "', argument " "3"" of type '" "int64_t""'");
  } 
  arg3 = static_cast< int64_t >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->set(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  FIX::DateTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_set" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_set" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DateTime_set" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DateTime * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->set((FIX::DateTime const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DateTime_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DateTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DateTime_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DateTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DateTime_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DateTime_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DateTime::set(int,int64_t)\n"
    "    FIX::DateTime::set(FIX::DateTime const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = (FIX::DateTime *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', argument " "1"" of type '" "FIX::DateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->operator +=(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_convertToNanos(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_convertToNanos", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_convertToNanos" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_convertToNanos" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)FIX::DateTime::convertToNanos(arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_makeHMS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int64_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_makeHMS", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_makeHMS" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_makeHMS" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_makeHMS" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_makeHMS" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int64_t)FIX::DateTime::makeHMS(arg1,arg2,arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_nowUtc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_nowUtc", 0, 0, 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::DateTime::nowUtc();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::DateTime(result)), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_nowLocal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_nowLocal", 0, 0, 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::DateTime::nowLocal();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::DateTime(result)), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_fromUtcTimeT__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::DateTime result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_fromUtcTimeT" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DateTime_fromUtcTimeT" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_fromUtcTimeT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::DateTime::fromUtcTimeT(SWIG_STD_MOVE(arg1),arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::DateTime(result)), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_fromUtcTimeT__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  FIX::DateTime result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_fromUtcTimeT" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DateTime_fromUtcTimeT" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::DateTime::fromUtcTimeT(SWIG_STD_MOVE(arg1));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::DateTime(result)), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_fromLocalTimeT__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::DateTime result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_fromLocalTimeT" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DateTime_fromLocalTimeT" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_fromLocalTimeT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::DateTime::fromLocalTimeT(SWIG_STD_MOVE(arg1),arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::DateTime(result)), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_fromLocalTimeT__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  FIX::DateTime result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_fromLocalTimeT" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DateTime_fromLocalTimeT" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::DateTime::fromLocalTimeT(SWIG_STD_MOVE(arg1));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::DateTime(result)), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_fromUtcTimeT__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  int arg2 ;
  int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::DateTime result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_fromUtcTimeT" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DateTime_fromUtcTimeT" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_fromUtcTimeT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_fromUtcTimeT" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::DateTime::fromUtcTimeT(SWIG_STD_MOVE(arg1),arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::DateTime(result)), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_fromUtcTimeT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DateTime_fromUtcTimeT", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DateTime_fromUtcTimeT__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DateTime_fromUtcTimeT__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DateTime_fromUtcTimeT__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DateTime_fromUtcTimeT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DateTime::fromUtcTimeT(time_t,int)\n"
    "    FIX::DateTime::fromUtcTimeT(time_t)\n"
    "    FIX::DateTime::fromUtcTimeT(time_t,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DateTime_fromLocalTimeT__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  int arg2 ;
  int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::DateTime result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_fromLocalTimeT" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DateTime_fromLocalTimeT" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_fromLocalTimeT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_fromLocalTimeT" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::DateTime::fromLocalTimeT(SWIG_STD_MOVE(arg1),arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::DateTime(result)), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_fromLocalTimeT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DateTime_fromLocalTimeT", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DateTime_fromLocalTimeT__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DateTime_fromLocalTimeT__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DateTime_fromLocalTimeT__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DateTime_fromLocalTimeT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DateTime::fromLocalTimeT(time_t,int)\n"
    "    FIX::DateTime::fromLocalTimeT(time_t)\n"
    "    FIX::DateTime::fromLocalTimeT(time_t,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DateTime_fromTm__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::DateTime result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_tm,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_fromTm" "', argument " "1"" of type '" "tm const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DateTime_fromTm" "', argument " "1"" of type '" "tm const &""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_fromTm" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::DateTime::fromTm((tm const &)*arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::DateTime(result)), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_fromTm__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::DateTime result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_tm,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_fromTm" "', argument " "1"" of type '" "tm const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DateTime_fromTm" "', argument " "1"" of type '" "tm const &""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::DateTime::fromTm((tm const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::DateTime(result)), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_fromTm__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::DateTime result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_tm,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_fromTm" "', argument " "1"" of type '" "tm const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DateTime_fromTm" "', argument " "1"" of type '" "tm const &""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_fromTm" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_fromTm" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::DateTime::fromTm((tm const &)*arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::DateTime(result)), SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateTime_fromTm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DateTime_fromTm", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_tm, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DateTime_fromTm__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_tm, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DateTime_fromTm__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_tm, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DateTime_fromTm__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DateTime_fromTm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DateTime::fromTm(tm const &,int)\n"
    "    FIX::DateTime::fromTm(tm const &)\n"
    "    FIX::DateTime::fromTm(tm const &,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DateTime_julianDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DateTime_julianDate", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_julianDate" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_julianDate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_julianDate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)FIX::DateTime::julianDate(arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap___eq____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = 0 ;
  FIX::DateTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DateTime * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::operator ==((FIX::DateTime const &)*arg1,(FIX::DateTime const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = 0 ;
  FIX::DateTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DateTime * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::operator !=((FIX::DateTime const &)*arg1,(FIX::DateTime const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = 0 ;
  FIX::DateTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lt__" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__lt__" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lt__" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__lt__" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DateTime * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::operator <((FIX::DateTime const &)*arg1,(FIX::DateTime const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = 0 ;
  FIX::DateTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__gt__" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__gt__" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__gt__" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__gt__" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DateTime * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::operator >((FIX::DateTime const &)*arg1,(FIX::DateTime const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___le____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = 0 ;
  FIX::DateTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__le__" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__le__" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__le__" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__le__" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DateTime * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::operator <=((FIX::DateTime const &)*arg1,(FIX::DateTime const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ge____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = 0 ;
  FIX::DateTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ge__" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__ge__" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ge__" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__ge__" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DateTime * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::operator >=((FIX::DateTime const &)*arg1,(FIX::DateTime const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = 0 ;
  FIX::DateTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "__sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__sub__" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__sub__" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__sub__" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__sub__" "', argument " "2"" of type '" "FIX::DateTime const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DateTime * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)FIX::operator -((FIX::DateTime const &)*arg1,(FIX::DateTime const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_UtcTimeStamp_now(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStamp result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UtcTimeStamp_now", 0, 0, 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::UtcTimeStamp::now();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::UtcTimeStamp(result)), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStamp *)new FIX::UtcTimeStamp();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  FIX::UtcTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DateTime,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "FIX::DateTime""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "FIX::DateTime""'");
    } else {
      FIX::DateTime * temp = reinterpret_cast< FIX::DateTime * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStamp *)new FIX::UtcTimeStamp(SWIG_STD_MOVE(arg1));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  FIX::UtcTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UtcTimeStamp" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStamp *)new FIX::UtcTimeStamp(arg1,arg2,arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::UtcTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStamp *)new FIX::UtcTimeStamp(arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  FIX::UtcTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UtcTimeStamp" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_UtcTimeStamp" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStamp *)new FIX::UtcTimeStamp(arg1,arg2,arg3,arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  FIX::UtcTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UtcTimeStamp" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_UtcTimeStamp" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UtcTimeStamp" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStamp *)new FIX::UtcTimeStamp(arg1,arg2,arg3,arg4,arg5,arg6);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  FIX::UtcTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UtcTimeStamp" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_UtcTimeStamp" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UtcTimeStamp" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UtcTimeStamp" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStamp *)new FIX::UtcTimeStamp(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  FIX::UtcTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UtcTimeStamp" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_UtcTimeStamp" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UtcTimeStamp" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UtcTimeStamp" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UtcTimeStamp" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStamp *)new FIX::UtcTimeStamp(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::UtcTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStamp *)new FIX::UtcTimeStamp(SWIG_STD_MOVE(arg1),arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  FIX::UtcTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStamp *)new FIX::UtcTimeStamp(SWIG_STD_MOVE(arg1));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  int arg2 ;
  int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::UtcTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStamp *)new FIX::UtcTimeStamp(SWIG_STD_MOVE(arg1),arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = (tm *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::UtcTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "tm const *""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStamp *)new FIX::UtcTimeStamp((tm const *)arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = (tm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::UtcTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "tm const *""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStamp *)new FIX::UtcTimeStamp((tm const *)arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = (tm *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::UtcTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcTimeStamp" "', argument " "1"" of type '" "tm const *""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStamp *)new FIX::UtcTimeStamp((tm const *)arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStamp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UtcTimeStamp", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UtcTimeStamp__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UtcTimeStamp__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UtcTimeStamp__SWIG_9(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UtcTimeStamp__SWIG_12(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UtcTimeStamp__SWIG_11(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UtcTimeStamp__SWIG_8(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UtcTimeStamp__SWIG_10(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UtcTimeStamp__SWIG_13(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UtcTimeStamp__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_UtcTimeStamp__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_UtcTimeStamp__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_UtcTimeStamp__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_UtcTimeStamp__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_UtcTimeStamp__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UtcTimeStamp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UtcTimeStamp::UtcTimeStamp()\n"
    "    FIX::UtcTimeStamp::UtcTimeStamp(FIX::DateTime)\n"
    "    FIX::UtcTimeStamp::UtcTimeStamp(int,int,int,int)\n"
    "    FIX::UtcTimeStamp::UtcTimeStamp(int,int,int)\n"
    "    FIX::UtcTimeStamp::UtcTimeStamp(int,int,int,int,int)\n"
    "    FIX::UtcTimeStamp::UtcTimeStamp(int,int,int,int,int,int)\n"
    "    FIX::UtcTimeStamp::UtcTimeStamp(int,int,int,int,int,int,int)\n"
    "    FIX::UtcTimeStamp::UtcTimeStamp(int,int,int,int,int,int,int,int)\n"
    "    FIX::UtcTimeStamp::UtcTimeStamp(time_t,int)\n"
    "    FIX::UtcTimeStamp::UtcTimeStamp(time_t)\n"
    "    FIX::UtcTimeStamp::UtcTimeStamp(time_t,int,int)\n"
    "    FIX::UtcTimeStamp::UtcTimeStamp(tm const *,int)\n"
    "    FIX::UtcTimeStamp::UtcTimeStamp(tm const *)\n"
    "    FIX::UtcTimeStamp::UtcTimeStamp(tm const *,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UtcTimeStamp_setCurrent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStamp *arg1 = (FIX::UtcTimeStamp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__UtcTimeStamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcTimeStamp_setCurrent" "', argument " "1"" of type '" "FIX::UtcTimeStamp *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStamp * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setCurrent();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeStamp_getDateTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStamp *arg1 = (FIX::UtcTimeStamp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__UtcTimeStamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcTimeStamp_getDateTime" "', argument " "1"" of type '" "FIX::UtcTimeStamp *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStamp * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (PyObject *)FIX_UtcTimeStamp_getDateTime(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UtcTimeStamp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStamp *arg1 = (FIX::UtcTimeStamp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UtcTimeStamp" "', argument " "1"" of type '" "FIX::UtcTimeStamp *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStamp * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_LocalTimeStamp__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::LocalTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeStamp *)new FIX::LocalTimeStamp();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeStamp__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  FIX::LocalTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LocalTimeStamp" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeStamp *)new FIX::LocalTimeStamp(arg1,arg2,arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeStamp__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::LocalTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeStamp *)new FIX::LocalTimeStamp(arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeStamp__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  FIX::LocalTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LocalTimeStamp" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LocalTimeStamp" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeStamp *)new FIX::LocalTimeStamp(arg1,arg2,arg3,arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeStamp__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  FIX::LocalTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LocalTimeStamp" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LocalTimeStamp" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LocalTimeStamp" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeStamp *)new FIX::LocalTimeStamp(arg1,arg2,arg3,arg4,arg5,arg6);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeStamp__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  FIX::LocalTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LocalTimeStamp" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LocalTimeStamp" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LocalTimeStamp" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_LocalTimeStamp" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeStamp *)new FIX::LocalTimeStamp(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeStamp__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  FIX::LocalTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LocalTimeStamp" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LocalTimeStamp" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LocalTimeStamp" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_LocalTimeStamp" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_LocalTimeStamp" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeStamp *)new FIX::LocalTimeStamp(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeStamp__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::LocalTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeStamp *)new FIX::LocalTimeStamp(SWIG_STD_MOVE(arg1),arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeStamp__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  FIX::LocalTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeStamp *)new FIX::LocalTimeStamp(SWIG_STD_MOVE(arg1));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeStamp__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  int arg2 ;
  int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::LocalTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeStamp *)new FIX::LocalTimeStamp(SWIG_STD_MOVE(arg1),arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeStamp__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = (tm *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::LocalTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "tm const *""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeStamp *)new FIX::LocalTimeStamp((tm const *)arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeStamp__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = (tm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::LocalTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "tm const *""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeStamp *)new FIX::LocalTimeStamp((tm const *)arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeStamp__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = (tm *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::LocalTimeStamp *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalTimeStamp" "', argument " "1"" of type '" "tm const *""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeStamp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalTimeStamp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeStamp *)new FIX::LocalTimeStamp((tm const *)arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeStamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeStamp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LocalTimeStamp", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_LocalTimeStamp__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocalTimeStamp__SWIG_8(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocalTimeStamp__SWIG_11(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LocalTimeStamp__SWIG_10(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LocalTimeStamp__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_LocalTimeStamp__SWIG_9(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_LocalTimeStamp__SWIG_12(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_LocalTimeStamp__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_LocalTimeStamp__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_LocalTimeStamp__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_LocalTimeStamp__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_LocalTimeStamp__SWIG_5(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_LocalTimeStamp__SWIG_6(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LocalTimeStamp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LocalTimeStamp::LocalTimeStamp()\n"
    "    FIX::LocalTimeStamp::LocalTimeStamp(int,int,int,int)\n"
    "    FIX::LocalTimeStamp::LocalTimeStamp(int,int,int)\n"
    "    FIX::LocalTimeStamp::LocalTimeStamp(int,int,int,int,int)\n"
    "    FIX::LocalTimeStamp::LocalTimeStamp(int,int,int,int,int,int)\n"
    "    FIX::LocalTimeStamp::LocalTimeStamp(int,int,int,int,int,int,int)\n"
    "    FIX::LocalTimeStamp::LocalTimeStamp(int,int,int,int,int,int,int,int)\n"
    "    FIX::LocalTimeStamp::LocalTimeStamp(time_t,int)\n"
    "    FIX::LocalTimeStamp::LocalTimeStamp(time_t)\n"
    "    FIX::LocalTimeStamp::LocalTimeStamp(time_t,int,int)\n"
    "    FIX::LocalTimeStamp::LocalTimeStamp(tm const *,int)\n"
    "    FIX::LocalTimeStamp::LocalTimeStamp(tm const *)\n"
    "    FIX::LocalTimeStamp::LocalTimeStamp(tm const *,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LocalTimeStamp_setCurrent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LocalTimeStamp *arg1 = (FIX::LocalTimeStamp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__LocalTimeStamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalTimeStamp_setCurrent" "', argument " "1"" of type '" "FIX::LocalTimeStamp *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LocalTimeStamp * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setCurrent();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LocalTimeStamp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LocalTimeStamp *arg1 = (FIX::LocalTimeStamp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__LocalTimeStamp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalTimeStamp" "', argument " "1"" of type '" "FIX::LocalTimeStamp *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LocalTimeStamp * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UtcTimeOnly__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnly *)new FIX::UtcTimeOnly();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnly__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::UtcTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcTimeOnly" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UtcTimeOnly" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnly *)new FIX::UtcTimeOnly((FIX::DateTime const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnly__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  FIX::UtcTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeOnly" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeOnly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeOnly" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UtcTimeOnly" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnly *)new FIX::UtcTimeOnly(arg1,arg2,arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnly__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::UtcTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeOnly" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeOnly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeOnly" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnly *)new FIX::UtcTimeOnly(arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnly__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  FIX::UtcTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeOnly" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeOnly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeOnly" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UtcTimeOnly" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_UtcTimeOnly" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnly *)new FIX::UtcTimeOnly(arg1,arg2,arg3,arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnly__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::UtcTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcTimeOnly" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UtcTimeOnly" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeOnly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnly *)new FIX::UtcTimeOnly(SWIG_STD_MOVE(arg1),arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnly__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  FIX::UtcTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcTimeOnly" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UtcTimeOnly" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnly *)new FIX::UtcTimeOnly(SWIG_STD_MOVE(arg1));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnly__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  int arg2 ;
  int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::UtcTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcTimeOnly" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UtcTimeOnly" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeOnly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeOnly" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnly *)new FIX::UtcTimeOnly(SWIG_STD_MOVE(arg1),arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnly__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = (tm *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::UtcTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcTimeOnly" "', argument " "1"" of type '" "tm const *""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeOnly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnly *)new FIX::UtcTimeOnly((tm const *)arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnly__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = (tm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::UtcTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcTimeOnly" "', argument " "1"" of type '" "tm const *""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnly *)new FIX::UtcTimeOnly((tm const *)arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnly__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = (tm *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::UtcTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcTimeOnly" "', argument " "1"" of type '" "tm const *""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeOnly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeOnly" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnly *)new FIX::UtcTimeOnly((tm const *)arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnly(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UtcTimeOnly", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UtcTimeOnly__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UtcTimeOnly__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UtcTimeOnly__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UtcTimeOnly__SWIG_9(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UtcTimeOnly__SWIG_8(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UtcTimeOnly__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UtcTimeOnly__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UtcTimeOnly__SWIG_10(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UtcTimeOnly__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_UtcTimeOnly__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_UtcTimeOnly__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UtcTimeOnly'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UtcTimeOnly::UtcTimeOnly()\n"
    "    FIX::UtcTimeOnly::UtcTimeOnly(FIX::DateTime const &)\n"
    "    FIX::UtcTimeOnly::UtcTimeOnly(int,int,int,int)\n"
    "    FIX::UtcTimeOnly::UtcTimeOnly(int,int,int)\n"
    "    FIX::UtcTimeOnly::UtcTimeOnly(int,int,int,int,int)\n"
    "    FIX::UtcTimeOnly::UtcTimeOnly(time_t,int)\n"
    "    FIX::UtcTimeOnly::UtcTimeOnly(time_t)\n"
    "    FIX::UtcTimeOnly::UtcTimeOnly(time_t,int,int)\n"
    "    FIX::UtcTimeOnly::UtcTimeOnly(tm const *,int)\n"
    "    FIX::UtcTimeOnly::UtcTimeOnly(tm const *)\n"
    "    FIX::UtcTimeOnly::UtcTimeOnly(tm const *,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UtcTimeOnly_setCurrent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnly *arg1 = (FIX::UtcTimeOnly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__UtcTimeOnly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcTimeOnly_setCurrent" "', argument " "1"" of type '" "FIX::UtcTimeOnly *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeOnly * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setCurrent();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UtcTimeOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnly *arg1 = (FIX::UtcTimeOnly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UtcTimeOnly" "', argument " "1"" of type '" "FIX::UtcTimeOnly *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeOnly * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_LocalTimeOnly__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::LocalTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeOnly *)new FIX::LocalTimeOnly();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeOnly__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::LocalTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalTimeOnly" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_LocalTimeOnly" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeOnly *)new FIX::LocalTimeOnly((FIX::DateTime const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeOnly__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  FIX::LocalTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalTimeOnly" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeOnly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalTimeOnly" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LocalTimeOnly" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeOnly *)new FIX::LocalTimeOnly(arg1,arg2,arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeOnly__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::LocalTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalTimeOnly" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeOnly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalTimeOnly" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeOnly *)new FIX::LocalTimeOnly(arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeOnly__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  FIX::LocalTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalTimeOnly" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeOnly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalTimeOnly" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LocalTimeOnly" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LocalTimeOnly" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeOnly *)new FIX::LocalTimeOnly(arg1,arg2,arg3,arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeOnly__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::LocalTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalTimeOnly" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_LocalTimeOnly" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeOnly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeOnly *)new FIX::LocalTimeOnly(SWIG_STD_MOVE(arg1),arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeOnly__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  FIX::LocalTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalTimeOnly" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_LocalTimeOnly" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeOnly *)new FIX::LocalTimeOnly(SWIG_STD_MOVE(arg1));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeOnly__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  time_t arg1 ;
  int arg2 ;
  int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::LocalTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_time_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalTimeOnly" "', argument " "1"" of type '" "time_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_LocalTimeOnly" "', argument " "1"" of type '" "time_t""'");
    } else {
      time_t * temp = reinterpret_cast< time_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeOnly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalTimeOnly" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeOnly *)new FIX::LocalTimeOnly(SWIG_STD_MOVE(arg1),arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeOnly__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = (tm *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::LocalTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalTimeOnly" "', argument " "1"" of type '" "tm const *""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeOnly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeOnly *)new FIX::LocalTimeOnly((tm const *)arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeOnly__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = (tm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::LocalTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalTimeOnly" "', argument " "1"" of type '" "tm const *""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeOnly *)new FIX::LocalTimeOnly((tm const *)arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeOnly__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = (tm *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::LocalTimeOnly *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalTimeOnly" "', argument " "1"" of type '" "tm const *""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalTimeOnly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalTimeOnly" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalTimeOnly *)new FIX::LocalTimeOnly((tm const *)arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalTimeOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalTimeOnly(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LocalTimeOnly", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_LocalTimeOnly__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocalTimeOnly__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocalTimeOnly__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocalTimeOnly__SWIG_9(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LocalTimeOnly__SWIG_8(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LocalTimeOnly__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_LocalTimeOnly__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_LocalTimeOnly__SWIG_10(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_LocalTimeOnly__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_LocalTimeOnly__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_LocalTimeOnly__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LocalTimeOnly'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LocalTimeOnly::LocalTimeOnly()\n"
    "    FIX::LocalTimeOnly::LocalTimeOnly(FIX::DateTime const &)\n"
    "    FIX::LocalTimeOnly::LocalTimeOnly(int,int,int,int)\n"
    "    FIX::LocalTimeOnly::LocalTimeOnly(int,int,int)\n"
    "    FIX::LocalTimeOnly::LocalTimeOnly(int,int,int,int,int)\n"
    "    FIX::LocalTimeOnly::LocalTimeOnly(time_t,int)\n"
    "    FIX::LocalTimeOnly::LocalTimeOnly(time_t)\n"
    "    FIX::LocalTimeOnly::LocalTimeOnly(time_t,int,int)\n"
    "    FIX::LocalTimeOnly::LocalTimeOnly(tm const *,int)\n"
    "    FIX::LocalTimeOnly::LocalTimeOnly(tm const *)\n"
    "    FIX::LocalTimeOnly::LocalTimeOnly(tm const *,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LocalTimeOnly_setCurrent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LocalTimeOnly *arg1 = (FIX::LocalTimeOnly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__LocalTimeOnly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalTimeOnly_setCurrent" "', argument " "1"" of type '" "FIX::LocalTimeOnly *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LocalTimeOnly * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setCurrent();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LocalTimeOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LocalTimeOnly *arg1 = (FIX::LocalTimeOnly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__LocalTimeOnly, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalTimeOnly" "', argument " "1"" of type '" "FIX::LocalTimeOnly *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LocalTimeOnly * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UtcDate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::UtcDate *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcDate *)new FIX::UtcDate();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcDate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::UtcDate *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcDate" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UtcDate" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcDate *)new FIX::UtcDate((FIX::DateTime const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcDate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::UtcDate *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcDate" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcDate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcDate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcDate *)new FIX::UtcDate(arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcDate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::UtcDate *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcDate" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcDate *)new FIX::UtcDate(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcDate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = (tm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::UtcDate *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UtcDate" "', argument " "1"" of type '" "tm const *""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcDate *)new FIX::UtcDate((tm const *)arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcDate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UtcDate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UtcDate__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UtcDate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UtcDate__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UtcDate__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UtcDate__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UtcDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UtcDate::UtcDate()\n"
    "    FIX::UtcDate::UtcDate(FIX::DateTime const &)\n"
    "    FIX::UtcDate::UtcDate(int,int,int)\n"
    "    FIX::UtcDate::UtcDate(int)\n"
    "    FIX::UtcDate::UtcDate(tm const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UtcDate_setCurrent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDate *arg1 = (FIX::UtcDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__UtcDate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcDate_setCurrent" "', argument " "1"" of type '" "FIX::UtcDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcDate * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setCurrent();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UtcDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDate *arg1 = (FIX::UtcDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__UtcDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UtcDate" "', argument " "1"" of type '" "FIX::UtcDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcDate * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_LocalDate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::LocalDate *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalDate *)new FIX::LocalDate();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalDate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DateTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::LocalDate *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DateTime,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalDate" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_LocalDate" "', argument " "1"" of type '" "FIX::DateTime const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateTime * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalDate *)new FIX::LocalDate((FIX::DateTime const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalDate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::LocalDate *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalDate" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalDate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalDate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalDate *)new FIX::LocalDate(arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalDate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::LocalDate *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalDate" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalDate *)new FIX::LocalDate(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalDate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  tm *arg1 = (tm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::LocalDate *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalDate" "', argument " "1"" of type '" "tm const *""'"); 
  }
  arg1 = reinterpret_cast< tm * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::LocalDate *)new FIX::LocalDate((tm const *)arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocalDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalDate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LocalDate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_LocalDate__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocalDate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocalDate__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LocalDate__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_LocalDate__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LocalDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LocalDate::LocalDate()\n"
    "    FIX::LocalDate::LocalDate(FIX::DateTime const &)\n"
    "    FIX::LocalDate::LocalDate(int,int,int)\n"
    "    FIX::LocalDate::LocalDate(int)\n"
    "    FIX::LocalDate::LocalDate(tm const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LocalDate_setCurrent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LocalDate *arg1 = (FIX::LocalDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__LocalDate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalDate_setCurrent" "', argument " "1"" of type '" "FIX::LocalDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LocalDate * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setCurrent();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LocalDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LocalDate *arg1 = (FIX::LocalDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__LocalDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalDate" "', argument " "1"" of type '" "FIX::LocalDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LocalDate * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_FieldBase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FIX::FieldBase *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_FieldBase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldBase *)new FIX::FieldBase(arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FieldBase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldBase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::FieldBase *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__FieldBase,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FieldBase" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FieldBase" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldBase *)new FIX::FieldBase((FIX::FieldBase const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldBase, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldBase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FieldBase", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FieldBase, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FieldBase__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FieldBase__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FieldBase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldBase::FieldBase(int,std::string const &)\n"
    "    FIX::FieldBase::FieldBase(FIX::FieldBase const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldBase_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  FIX::FieldBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldBase_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldBase_swap" "', argument " "1"" of type '" "FIX::FieldBase *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldBase_swap" "', argument " "2"" of type '" "FIX::FieldBase &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "FieldBase_swap" "', argument " "2"" of type '" "FIX::FieldBase &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->swap(*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_setTag(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldBase_setTag", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldBase_setTag" "', argument " "1"" of type '" "FIX::FieldBase *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldBase_setTag" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setTag(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_setField(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldBase_setField", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setField(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_setString(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldBase_setString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "FieldBase_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setString((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_getTag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldBase_getTag" "', argument " "1"" of type '" "FIX::FieldBase const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::FieldBase const *)arg1)->getTag();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_getField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::FieldBase const *)arg1)->getField();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_getString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::FieldBase const *)arg1)->getString();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_FieldBase_getLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::FieldBase const *)arg1)->getLength();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_getTotal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::FieldBase const *)arg1)->getTotal();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  FIX::FieldBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldBase___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "FieldBase___lt__" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::FieldBase const *)arg1)->operator <((FIX::FieldBase const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_FieldBase___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX_FieldBase___str__(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  FIX::FieldBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::ostream *) &FIX::operator <<(*arg1,(FIX::FieldBase const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = 0 ;
  FIX::FieldBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swap" "', argument " "1"" of type '" "FIX::FieldBase &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "swap" "', argument " "1"" of type '" "FIX::FieldBase &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "swap" "', argument " "2"" of type '" "FIX::FieldBase &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "swap" "', argument " "2"" of type '" "FIX::FieldBase &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            FIX::swap(*arg1,*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FIX::StringField *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_StringField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::StringField *)new FIX::StringField(arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::StringField *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::StringField *)new FIX::StringField(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringField(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_StringField", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_StringField__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_StringField__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_StringField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StringField::StringField(int,std::string const &)\n"
    "    FIX::StringField::StringField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringField_setValue(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringField_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "StringField_setValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setValue((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringField_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::StringField const *)arg1)->getValue();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringField___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringField___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "StringField___lt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::StringField const *)arg1)->operator <((FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_StringField___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringField___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "StringField___gt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::StringField const *)arg1)->operator >((FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_StringField___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringField___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "StringField___eq__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::StringField const *)arg1)->operator ==((FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_StringField___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringField___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "StringField___ne__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::StringField const *)arg1)->operator !=((FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_StringField___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringField___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "StringField___le__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::StringField const *)arg1)->operator <=((FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_StringField___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringField___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "StringField___ge__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::StringField const *)arg1)->operator >=((FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__lt__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator <((FIX::StringField const &)*arg1,(char const *)arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lt__" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__lt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator <((char const *)arg1,(FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__gt__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator >((FIX::StringField const &)*arg1,(char const *)arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__gt__" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__gt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator >((char const *)arg1,(FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___eq____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator ==((FIX::StringField const &)*arg1,(char const *)arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___eq____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator ==((char const *)arg1,(FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator !=((FIX::StringField const &)*arg1,(char const *)arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator !=((char const *)arg1,(FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___le____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__le__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator <=((FIX::StringField const &)*arg1,(char const *)arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___le____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__le__" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__le__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator <=((char const *)arg1,(FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ge____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__ge__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator >=((FIX::StringField const &)*arg1,(char const *)arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ge____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ge__" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__ge__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator >=((char const *)arg1,(FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__lt__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator <((FIX::StringField const &)*arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__lt__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__lt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator <((std::string const &)*arg1,(FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__gt__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator >((FIX::StringField const &)*arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__gt__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__gt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator >((std::string const &)*arg1,(FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___gt__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__gt__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gt____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gt____SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gt____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gt____SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gt____SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___eq____SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator ==((FIX::StringField const &)*arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___eq____SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator ==((std::string const &)*arg1,(FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator !=((FIX::StringField const &)*arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator !=((std::string const &)*arg1,(FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___le____SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__le__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator <=((FIX::StringField const &)*arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___le____SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__le__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__le__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator <=((std::string const &)*arg1,(FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___le__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__le__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___le____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___le____SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___le____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___le____SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___le____SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ge____SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__ge__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator >=((FIX::StringField const &)*arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ge____SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__ge__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__ge__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator >=((std::string const &)*arg1,(FIX::StringField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ge__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__ge__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ge____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ge____SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ge____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ge____SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ge____SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_StringField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_CharField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  char arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  FIX::CharField *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::CharField *)new FIX::CharField(arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CharField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CharField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::CharField *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CharField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::CharField *)new FIX::CharField(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CharField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CharField(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CharField", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CharField__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_CharField__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CharField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CharField::CharField(int,char)\n"
    "    FIX::CharField::CharField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CharField_setValue(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "CharField_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setValue(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CharField_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CharField *arg1 = (FIX::CharField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (char)((FIX::CharField const *)arg1)->getValue();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CharField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CharField *arg1 = (FIX::CharField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_DoubleField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::DoubleField *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DoubleField *)new FIX::DoubleField(arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DoubleField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  FIX::DoubleField *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DoubleField *)new FIX::DoubleField(arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DoubleField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleField__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::DoubleField *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DoubleField *)new FIX::DoubleField(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DoubleField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleField(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DoubleField", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DoubleField__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DoubleField__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_DoubleField__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DoubleField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DoubleField::DoubleField(int,double,int)\n"
    "    FIX::DoubleField::DoubleField(int,double)\n"
    "    FIX::DoubleField::DoubleField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleField_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setValue(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleField_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DoubleField *arg1 = (FIX::DoubleField *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setValue(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleField_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleField_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DoubleField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DoubleField_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DoubleField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DoubleField_setValue__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleField_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DoubleField::setValue(double,int)\n"
    "    FIX::DoubleField::setValue(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleField_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DoubleField *arg1 = (FIX::DoubleField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (double)((FIX::DoubleField const *)arg1)->getValue();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DoubleField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DoubleField *arg1 = (FIX::DoubleField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_IntField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::IntField *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::IntField *)new FIX::IntField(arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IntField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::IntField *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::IntField *)new FIX::IntField(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IntField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntField(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IntField", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_IntField__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_IntField__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IntField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IntField::IntField(int,int)\n"
    "    FIX::IntField::IntField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntField_setValue(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IntField_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setValue(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntField_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IntField *arg1 = (FIX::IntField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::IntField const *)arg1)->getValue();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IntField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IntField *arg1 = (FIX::IntField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Int64Field__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int64_t arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  FIX::Int64Field *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Int64Field" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Int64Field" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = static_cast< int64_t >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Int64Field *)new FIX::Int64Field(arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Int64Field, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Int64Field__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::Int64Field *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Int64Field" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Int64Field *)new FIX::Int64Field(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Int64Field, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Int64Field(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Int64Field", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Int64Field__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Int64Field__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Int64Field'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Int64Field::Int64Field(int,int64_t)\n"
    "    FIX::Int64Field::Int64Field(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Int64Field_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Int64Field *arg1 = (FIX::Int64Field *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Int64Field_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Int64Field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Int64Field_setValue" "', argument " "1"" of type '" "FIX::Int64Field *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Int64Field * >(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Int64Field_setValue" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = static_cast< int64_t >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setValue(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Int64Field_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Int64Field *arg1 = (FIX::Int64Field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Int64Field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Int64Field_getValue" "', argument " "1"" of type '" "FIX::Int64Field const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Int64Field * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int64_t)((FIX::Int64Field const *)arg1)->getValue();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Int64Field(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Int64Field *arg1 = (FIX::Int64Field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Int64Field, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Int64Field" "', argument " "1"" of type '" "FIX::Int64Field *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Int64Field * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UInt64Field__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  uint64_t arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  FIX::UInt64Field *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UInt64Field" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UInt64Field" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UInt64Field *)new FIX::UInt64Field(arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UInt64Field, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UInt64Field__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::UInt64Field *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UInt64Field" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UInt64Field *)new FIX::UInt64Field(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UInt64Field, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UInt64Field(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UInt64Field", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UInt64Field__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UInt64Field__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UInt64Field'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UInt64Field::UInt64Field(int,uint64_t)\n"
    "    FIX::UInt64Field::UInt64Field(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UInt64Field_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UInt64Field *arg1 = (FIX::UInt64Field *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UInt64Field_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__UInt64Field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UInt64Field_setValue" "', argument " "1"" of type '" "FIX::UInt64Field *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UInt64Field * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UInt64Field_setValue" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setValue(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UInt64Field_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UInt64Field *arg1 = (FIX::UInt64Field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__UInt64Field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UInt64Field_getValue" "', argument " "1"" of type '" "FIX::UInt64Field const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UInt64Field * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (uint64_t)((FIX::UInt64Field const *)arg1)->getValue();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UInt64Field(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UInt64Field *arg1 = (FIX::UInt64Field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__UInt64Field, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UInt64Field" "', argument " "1"" of type '" "FIX::UInt64Field *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UInt64Field * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_BoolField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  bool arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  FIX::BoolField *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::BoolField *)new FIX::BoolField(arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BoolField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BoolField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::BoolField *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoolField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::BoolField *)new FIX::BoolField(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BoolField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BoolField(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BoolField", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_BoolField__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BoolField__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BoolField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BoolField::BoolField(int,bool)\n"
    "    FIX::BoolField::BoolField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BoolField_setValue(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BoolField_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setValue(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolField_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BoolField *arg1 = (FIX::BoolField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::BoolField const *)arg1)->getValue();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_delete_BoolField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BoolField *arg1 = (FIX::BoolField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UtcTimeStampField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::UtcTimeStampField *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UtcTimeStampField" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UtcTimeStampField" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeStampField" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStampField *)new FIX::UtcTimeStampField(arg1,(FIX::UtcTimeStamp const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStampField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStampField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FIX::UtcTimeStampField *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UtcTimeStampField" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UtcTimeStampField" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStampField *)new FIX::UtcTimeStampField(arg1,(FIX::UtcTimeStamp const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStampField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStampField__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::UtcTimeStampField *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeStampField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStampField *)new FIX::UtcTimeStampField(arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStampField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStampField__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::UtcTimeStampField *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeStampField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeStampField *)new FIX::UtcTimeStampField(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStampField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStampField(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UtcTimeStampField", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UtcTimeStampField__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UtcTimeStampField__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UtcTimeStampField__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UtcTimeStampField__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UtcTimeStampField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UtcTimeStampField::UtcTimeStampField(int,FIX::UtcTimeStamp const &,int)\n"
    "    FIX::UtcTimeStampField::UtcTimeStampField(int,FIX::UtcTimeStamp const &)\n"
    "    FIX::UtcTimeStampField::UtcTimeStampField(int,int)\n"
    "    FIX::UtcTimeStampField::UtcTimeStampField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UtcTimeStampField_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UtcTimeStampField_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcTimeStampField_setValue" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UtcTimeStampField_setValue" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setValue((FIX::UtcTimeStamp const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeStampField_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::UtcTimeStamp result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::UtcTimeStampField const *)arg1)->getValue();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::UtcTimeStamp(result)), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeStampField___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  FIX::UtcTimeStampField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UtcTimeStampField___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "UtcTimeStampField___lt__" "', argument " "2"" of type '" "FIX::UtcTimeStampField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStampField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::UtcTimeStampField const *)arg1)->operator <((FIX::UtcTimeStampField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_UtcTimeStampField___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  FIX::UtcTimeStampField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UtcTimeStampField___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "UtcTimeStampField___eq__" "', argument " "2"" of type '" "FIX::UtcTimeStampField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStampField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::UtcTimeStampField const *)arg1)->operator ==((FIX::UtcTimeStampField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_UtcTimeStampField___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  FIX::UtcTimeStampField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UtcTimeStampField___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "UtcTimeStampField___ne__" "', argument " "2"" of type '" "FIX::UtcTimeStampField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStampField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::UtcTimeStampField const *)arg1)->operator !=((FIX::UtcTimeStampField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_UtcTimeStampField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UtcDateField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::UtcDate *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FIX::UtcDateField *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcDate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UtcDateField" "', argument " "2"" of type '" "FIX::UtcDate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UtcDateField" "', argument " "2"" of type '" "FIX::UtcDate const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcDate * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcDateField *)new FIX::UtcDateField(arg1,(FIX::UtcDate const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcDateField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcDateField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::UtcDateField *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcDateField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcDateField *)new FIX::UtcDateField(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcDateField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcDateField(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UtcDateField", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UtcDateField__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__UtcDate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UtcDateField__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UtcDateField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UtcDateField::UtcDateField(int,FIX::UtcDate const &)\n"
    "    FIX::UtcDateField::UtcDateField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UtcDateField_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  FIX::UtcDate *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UtcDateField_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcDate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcDateField_setValue" "', argument " "2"" of type '" "FIX::UtcDate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UtcDateField_setValue" "', argument " "2"" of type '" "FIX::UtcDate const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcDate * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setValue((FIX::UtcDate const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcDateField_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::UtcDate result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::UtcDateField const *)arg1)->getValue();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::UtcDate(result)), SWIGTYPE_p_FIX__UtcDate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcDateField___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  FIX::UtcDateField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UtcDateField___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "UtcDateField___lt__" "', argument " "2"" of type '" "FIX::UtcDateField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcDateField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::UtcDateField const *)arg1)->operator <((FIX::UtcDateField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_UtcDateField___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  FIX::UtcDateField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UtcDateField___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "UtcDateField___eq__" "', argument " "2"" of type '" "FIX::UtcDateField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcDateField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::UtcDateField const *)arg1)->operator ==((FIX::UtcDateField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_UtcDateField___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  FIX::UtcDateField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UtcDateField___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "UtcDateField___ne__" "', argument " "2"" of type '" "FIX::UtcDateField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcDateField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::UtcDateField const *)arg1)->operator !=((FIX::UtcDateField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_UtcDateField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UtcTimeOnlyField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::UtcTimeOnly *arg2 = 0 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeOnly,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UtcTimeOnlyField" "', argument " "2"" of type '" "FIX::UtcTimeOnly const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UtcTimeOnlyField" "', argument " "2"" of type '" "FIX::UtcTimeOnly const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeOnly * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeOnlyField" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnlyField *)new FIX::UtcTimeOnlyField(arg1,(FIX::UtcTimeOnly const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnlyField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnlyField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::UtcTimeOnly *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeOnly,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UtcTimeOnlyField" "', argument " "2"" of type '" "FIX::UtcTimeOnly const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UtcTimeOnlyField" "', argument " "2"" of type '" "FIX::UtcTimeOnly const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeOnly * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnlyField *)new FIX::UtcTimeOnlyField(arg1,(FIX::UtcTimeOnly const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnlyField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnlyField__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeOnlyField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnlyField *)new FIX::UtcTimeOnlyField(arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnlyField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnlyField__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeOnlyField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::UtcTimeOnlyField *)new FIX::UtcTimeOnlyField(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnlyField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnlyField(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UtcTimeOnlyField", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UtcTimeOnlyField__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UtcTimeOnlyField__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UtcTimeOnlyField__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UtcTimeOnlyField__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UtcTimeOnlyField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UtcTimeOnlyField::UtcTimeOnlyField(int,FIX::UtcTimeOnly const &,int)\n"
    "    FIX::UtcTimeOnlyField::UtcTimeOnlyField(int,FIX::UtcTimeOnly const &)\n"
    "    FIX::UtcTimeOnlyField::UtcTimeOnlyField(int,int)\n"
    "    FIX::UtcTimeOnlyField::UtcTimeOnlyField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UtcTimeOnlyField_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  FIX::UtcTimeOnly *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UtcTimeOnlyField_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeOnly,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcTimeOnlyField_setValue" "', argument " "2"" of type '" "FIX::UtcTimeOnly const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UtcTimeOnlyField_setValue" "', argument " "2"" of type '" "FIX::UtcTimeOnly const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeOnly * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setValue((FIX::UtcTimeOnly const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeOnlyField_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::UtcTimeOnly result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::UtcTimeOnlyField const *)arg1)->getValue();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::UtcTimeOnly(result)), SWIGTYPE_p_FIX__UtcTimeOnly, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeOnlyField___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  FIX::UtcTimeOnlyField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UtcTimeOnlyField___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "UtcTimeOnlyField___lt__" "', argument " "2"" of type '" "FIX::UtcTimeOnlyField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::UtcTimeOnlyField const *)arg1)->operator <((FIX::UtcTimeOnlyField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_UtcTimeOnlyField___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  FIX::UtcTimeOnlyField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UtcTimeOnlyField___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "UtcTimeOnlyField___eq__" "', argument " "2"" of type '" "FIX::UtcTimeOnlyField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::UtcTimeOnlyField const *)arg1)->operator ==((FIX::UtcTimeOnlyField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_UtcTimeOnlyField___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  FIX::UtcTimeOnlyField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "UtcTimeOnlyField___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "UtcTimeOnlyField___ne__" "', argument " "2"" of type '" "FIX::UtcTimeOnlyField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::UtcTimeOnlyField const *)arg1)->operator !=((FIX::UtcTimeOnlyField const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_UtcTimeOnlyField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_CheckSumField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::CheckSumField *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::CheckSumField *)new FIX::CheckSumField(arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CheckSumField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CheckSumField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FIX::CheckSumField *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CheckSumField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::CheckSumField *)new FIX::CheckSumField(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CheckSumField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CheckSumField(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CheckSumField", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CheckSumField__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_CheckSumField__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CheckSumField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CheckSumField::CheckSumField(int,int)\n"
    "    FIX::CheckSumField::CheckSumField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CheckSumField_setValue(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "CheckSumField_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setValue(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CheckSumField_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CheckSumField *arg1 = (FIX::CheckSumField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::CheckSumField const *)arg1)->getValue();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CheckSumField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CheckSumField *arg1 = (FIX::CheckSumField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_FieldMap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  message_order *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::FieldMap *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_FieldMap" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  arg1 = reinterpret_cast< message_order * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldMap *)new FIX::FieldMap((message_order const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldMap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::FieldMap *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldMap *)new FIX::FieldMap();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldMap__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) (int *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::FieldMap *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldMap *)new FIX::FieldMap((int const (*))arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldMap__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::FieldMap *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_FieldMap" "', argument " "1"" of type '" "FIX::FieldMap const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldMap *)new FIX::FieldMap((FIX::FieldMap const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldMap__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< FIX::FieldMap > rvrdeleter1 ;
  FIX::FieldMap *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__FieldMap, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FieldMap" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "FIX::FieldMap &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FieldMap" "', argument " "1"" of type '" "FIX::FieldMap &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FieldMap" "', argument " "1"" of type '" "FIX::FieldMap &&""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldMap *)new FIX::FieldMap((FIX::FieldMap &&)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldMap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FieldMap", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_FieldMap__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FieldMap__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FieldMap__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FieldMap, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FieldMap__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FieldMap__SWIG_5(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FieldMap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::FieldMap(message_order const &)\n"
    "    FIX::FieldMap::FieldMap()\n"
    "    FIX::FieldMap::FieldMap(int const [])\n"
    "    FIX::FieldMap::FieldMap(FIX::FieldMap const &)\n"
    "    FIX::FieldMap::FieldMap(FIX::FieldMap &&)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FieldMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_setField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "FieldMap_setField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setField((FIX::FieldBase const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_setField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "FieldMap_setField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setField((FIX::FieldBase const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_setField__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "FieldMap_setField" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setField(arg2,(std::string const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_FieldMap_getFieldIfSet(PyObject *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 *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldMap_getFieldIfSet", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_getFieldIfSet" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldMap_getFieldIfSet" "', argument " "2"" of type '" "FIX::FieldBase &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "FieldMap_getFieldIfSet" "', argument " "2"" of type '" "FIX::FieldBase &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::FieldMap const *)arg1)->getFieldIfSet(*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  FIX::FieldBase *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "FieldMap_getField" "', argument " "2"" of type '" "FIX::FieldBase &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldBase *) &((FIX::FieldMap const *)arg1)->getField(*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::FieldMap const *)arg1)->getField(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_FieldMap_getFieldRef(PyObject *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 *swig_obj[2] ;
  FIX::FieldBase *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldMap_getFieldRef", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldBase *) &((FIX::FieldMap const *)arg1)->getFieldRef(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getFieldPtr(PyObject *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 *swig_obj[2] ;
  FIX::FieldBase *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldMap_getFieldPtr", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldBase *)((FIX::FieldMap const *)arg1)->getFieldPtr(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_isSetField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "FieldMap_isSetField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::FieldMap const *)arg1)->isSetField((FIX::FieldBase const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_isSetField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::FieldMap const *)arg1)->isSetField(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_FieldMap_removeField(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldMap_removeField", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->removeField(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_addGroup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "FieldMap_addGroup" "', argument " "3"" of type '" "FIX::FieldMap const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::FieldMap * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addGroup(arg2,(FIX::FieldMap const &)*arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_addGroup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "FieldMap_addGroup" "', argument " "3"" of type '" "FIX::FieldMap const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::FieldMap * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addGroup(arg2,(FIX::FieldMap const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_FieldMap_addGroupPtr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  FIX::FieldMap *arg3 = (FIX::FieldMap *) 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 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_addGroupPtr" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_addGroupPtr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FieldMap_addGroupPtr" "', argument " "3"" of type '" "FIX::FieldMap *""'"); 
  }
  arg3 = reinterpret_cast< FIX::FieldMap * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FieldMap_addGroupPtr" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addGroupPtr(arg2,arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_addGroupPtr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  FIX::FieldMap *arg3 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_addGroupPtr" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_addGroupPtr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FieldMap_addGroupPtr" "', argument " "3"" of type '" "FIX::FieldMap *""'"); 
  }
  arg3 = reinterpret_cast< FIX::FieldMap * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addGroupPtr(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_addGroupPtr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FieldMap_addGroupPtr", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    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) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_FieldMap_addGroupPtr__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    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) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FieldMap_addGroupPtr__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FieldMap_addGroupPtr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::addGroupPtr(int,FIX::FieldMap *,bool)\n"
    "    FIX::FieldMap::addGroupPtr(int,FIX::FieldMap *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_replaceGroup(PyObject *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 *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldMap_replaceGroup", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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(swig_obj[3], &argp4, SWIGTYPE_p_FIX__FieldMap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FieldMap_replaceGroup" "', argument " "4"" of type '" "FIX::FieldMap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "FieldMap_replaceGroup" "', argument " "4"" of type '" "FIX::FieldMap const &""'"); 
  }
  arg4 = reinterpret_cast< FIX::FieldMap * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->replaceGroup(arg2,arg3,(FIX::FieldMap const &)*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getGroup(PyObject *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 *swig_obj[4] ;
  FIX::FieldMap *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldMap_getGroup", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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(swig_obj[3], &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_NullReferenceError, "invalid null reference " "in method '" "FieldMap_getGroup" "', argument " "4"" of type '" "FIX::FieldMap &""'"); 
  }
  arg4 = reinterpret_cast< FIX::FieldMap * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldMap *) &((FIX::FieldMap const *)arg1)->getGroup(arg2,arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getGroupRef(PyObject *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 *swig_obj[3] ;
  FIX::FieldMap *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldMap_getGroupRef", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldMap *) &((FIX::FieldMap const *)arg1)->getGroupRef(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getGroupPtr(PyObject *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 *swig_obj[3] ;
  FIX::FieldMap *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldMap_getGroupPtr", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldMap *)((FIX::FieldMap const *)arg1)->getGroupPtr(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_groups(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::FieldMap::Groups *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_groups" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FieldMap::Groups *) &((FIX::FieldMap const *)arg1)->groups();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_removeGroup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->removeGroup(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_removeGroup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->removeGroup(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_removeGroup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FieldMap_removeGroup", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_removeGroup__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FieldMap_removeGroup__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FieldMap_removeGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::removeGroup(int,int)\n"
    "    FIX::FieldMap::removeGroup(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_hasGroup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::FieldMap const *)arg1)->hasGroup(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_hasGroup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::FieldMap const *)arg1)->hasGroup(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_hasGroup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FieldMap_hasGroup", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_hasGroup__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FieldMap_hasGroup__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FieldMap_hasGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::hasGroup(int) const\n"
    "    FIX::FieldMap::hasGroup(int,int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_groupCount(PyObject *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 *swig_obj[2] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldMap_groupCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::FieldMap const *)arg1)->groupCount(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->clear();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_isEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->isEmpty();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_totalFields(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::FieldMap const *)arg1)->totalFields();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  PyObject *swig_obj[2] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldMap_calculateString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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*)PyUnicode_AsUTF8(swig_obj[1]));
    arg2 = &temp2;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::FieldMap const *)arg1)->calculateString(*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateLength__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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(swig_obj[3], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::FieldMap const *)arg1)->calculateLength(arg2,arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateLength__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::FieldMap const *)arg1)->calculateLength(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateLength__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::FieldMap const *)arg1)->calculateLength(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateLength__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::FieldMap const *)arg1)->calculateLength();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateLength(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FieldMap_calculateLength", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FieldMap_calculateLength__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_calculateLength__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FieldMap_calculateLength__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FieldMap_calculateLength__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FieldMap_calculateLength'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::calculateLength(int,int,int) const\n"
    "    FIX::FieldMap::calculateLength(int,int) const\n"
    "    FIX::FieldMap::calculateLength(int) const\n"
    "    FIX::FieldMap::calculateLength() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateTotal__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::FieldMap const *)arg1)->calculateTotal(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateTotal__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::FieldMap const *)arg1)->calculateTotal();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_FieldMap_begin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::vector< FIX::FieldBase,ALLOCATOR< FIX::FieldBase > >::iterator > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->begin();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::FieldMap::iterator(result)), SWIGTYPE_p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_end__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::vector< FIX::FieldBase,ALLOCATOR< FIX::FieldBase > >::iterator > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->end();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::FieldMap::iterator(result)), SWIGTYPE_p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_begin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::vector< FIX::FieldBase,ALLOCATOR< FIX::FieldBase > >::const_iterator > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::FieldMap const *)arg1)->begin();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::FieldMap::const_iterator(result)), SWIGTYPE_p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_begin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FieldMap_begin", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FieldMap_begin__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FieldMap_begin__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FieldMap_begin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::begin()\n"
    "    FIX::FieldMap::begin() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_end__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::vector< FIX::FieldBase,ALLOCATOR< FIX::FieldBase > >::const_iterator > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::FieldMap const *)arg1)->end();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::FieldMap::const_iterator(result)), SWIGTYPE_p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_end(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FieldMap_end", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FieldMap_end__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FieldMap_end__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FieldMap_end'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::end()\n"
    "    FIX::FieldMap::end() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_g_begin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::map< int,std::vector< FIX::FieldMap *,std::allocator< FIX::FieldMap * > >,std::less< int >,ALLOCATOR< std::pair< int const,std::vector< FIX::FieldMap *,std::allocator< FIX::FieldMap * > > > > >::iterator > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->g_begin();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::FieldMap::g_iterator(result)), SWIGTYPE_p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_g_end__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::map< int,std::vector< FIX::FieldMap *,std::allocator< FIX::FieldMap * > >,std::less< int >,ALLOCATOR< std::pair< int const,std::vector< FIX::FieldMap *,std::allocator< FIX::FieldMap * > > > > >::iterator > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->g_end();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::FieldMap::g_iterator(result)), SWIGTYPE_p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_g_begin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::map< int,std::vector< FIX::FieldMap *,std::allocator< FIX::FieldMap * > >,std::less< int >,ALLOCATOR< std::pair< int const,std::vector< FIX::FieldMap *,std::allocator< FIX::FieldMap * > > > > >::const_iterator > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::FieldMap const *)arg1)->g_begin();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::FieldMap::g_const_iterator(result)), SWIGTYPE_p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_g_begin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FieldMap_g_begin", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FieldMap_g_begin__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FieldMap_g_begin__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FieldMap_g_begin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::g_begin()\n"
    "    FIX::FieldMap::g_begin() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_g_end__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::map< int,std::vector< FIX::FieldMap *,std::allocator< FIX::FieldMap * > >,std::less< int >,ALLOCATOR< std::pair< int const,std::vector< FIX::FieldMap *,std::allocator< FIX::FieldMap * > > > > >::const_iterator > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::FieldMap const *)arg1)->g_end();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::FieldMap::g_const_iterator(result)), SWIGTYPE_p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_g_end(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FieldMap_g_end", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FieldMap_g_end__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FieldMap_g_end__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FieldMap_g_end'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::g_end()\n"
    "    FIX::FieldMap::g_end() const\n");
  return 0;
}


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

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

SWIGINTERN PyObject *_wrap_new_Header__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::Header *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Header *)new FIX::Header();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Header, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Header__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  message_order *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Header *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Header" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Header" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  arg1 = reinterpret_cast< message_order * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Header *)new FIX::Header((message_order const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Header, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Header(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Header", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Header__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Header__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Header'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Header::Header()\n"
    "    FIX::Header::Header(message_order const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Header_addGroup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Header *arg1 = (FIX::Header *) 0 ;
  FIX::Group *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Header_addGroup", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_addGroup" "', argument " "1"" of type '" "FIX::Header *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Header * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_addGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Header_addGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addGroup((FIX::Group const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Header_replaceGroup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Header *arg1 = (FIX::Header *) 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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Header_replaceGroup", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_replaceGroup" "', argument " "1"" of type '" "FIX::Header *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Header * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Header_replaceGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Header_replaceGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Header_replaceGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->replaceGroup(arg2,(FIX::Group const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Header_getGroup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Header *arg1 = (FIX::Header *) 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 *swig_obj[3] ;
  Group *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Header_getGroup", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_getGroup" "', argument " "1"" of type '" "FIX::Header const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Header * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Header_getGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Header_getGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Header_getGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (Group *) &((FIX::Header const *)arg1)->getGroup(arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Group, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Header_removeGroup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Header *arg1 = (FIX::Header *) 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_removeGroup" "', argument " "1"" of type '" "FIX::Header *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Header * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Header_removeGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Header_removeGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Header_removeGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->removeGroup(arg2,(FIX::Group const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Header_removeGroup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Header *arg1 = (FIX::Header *) 0 ;
  FIX::Group *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_removeGroup" "', argument " "1"" of type '" "FIX::Header *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Header * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_removeGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Header_removeGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->removeGroup((FIX::Group const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Header_removeGroup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Header_removeGroup", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Header, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__Group, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Header_removeGroup__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Header, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__Group, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Header_removeGroup__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Header_removeGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Header::removeGroup(unsigned int,FIX::Group const &)\n"
    "    FIX::Header::removeGroup(FIX::Group const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Header_hasGroup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Header *arg1 = (FIX::Header *) 0 ;
  FIX::Group *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_hasGroup" "', argument " "1"" of type '" "FIX::Header const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Header * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_hasGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Header_hasGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Header const *)arg1)->hasGroup((FIX::Group const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Header_hasGroup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Header *arg1 = (FIX::Header *) 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 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_hasGroup" "', argument " "1"" of type '" "FIX::Header const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Header * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Header_hasGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Header_hasGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Header_hasGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Header const *)arg1)->hasGroup(arg2,(FIX::Group const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Header_hasGroup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Header_hasGroup", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Header, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__Group, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Header_hasGroup__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Header, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__Group, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Header_hasGroup__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Header_hasGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Header::hasGroup(FIX::Group const &) const\n"
    "    FIX::Header::hasGroup(unsigned int,FIX::Group const &) const\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_Trailer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::Trailer *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Trailer *)new FIX::Trailer();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Trailer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Trailer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  message_order *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Trailer *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Trailer" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Trailer" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  arg1 = reinterpret_cast< message_order * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Trailer *)new FIX::Trailer((message_order const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Trailer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Trailer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Trailer", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Trailer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Trailer__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Trailer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Trailer::Trailer()\n"
    "    FIX::Trailer::Trailer(message_order const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Trailer_addGroup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Trailer *arg1 = (FIX::Trailer *) 0 ;
  FIX::Group *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Trailer_addGroup", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Trailer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trailer_addGroup" "', argument " "1"" of type '" "FIX::Trailer *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Trailer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Trailer_addGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Trailer_addGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addGroup((FIX::Group const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trailer_replaceGroup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Trailer *arg1 = (FIX::Trailer *) 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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Trailer_replaceGroup", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Trailer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trailer_replaceGroup" "', argument " "1"" of type '" "FIX::Trailer *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Trailer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Trailer_replaceGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Trailer_replaceGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Trailer_replaceGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->replaceGroup(arg2,(FIX::Group const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trailer_getGroup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Trailer *arg1 = (FIX::Trailer *) 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 *swig_obj[3] ;
  Group *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Trailer_getGroup", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Trailer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trailer_getGroup" "', argument " "1"" of type '" "FIX::Trailer const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Trailer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Trailer_getGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Trailer_getGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Trailer_getGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (Group *) &((FIX::Trailer const *)arg1)->getGroup(arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Group, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trailer_removeGroup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Trailer *arg1 = (FIX::Trailer *) 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Trailer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trailer_removeGroup" "', argument " "1"" of type '" "FIX::Trailer *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Trailer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Trailer_removeGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Trailer_removeGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Trailer_removeGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->removeGroup(arg2,(FIX::Group const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trailer_removeGroup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Trailer *arg1 = (FIX::Trailer *) 0 ;
  FIX::Group *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Trailer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trailer_removeGroup" "', argument " "1"" of type '" "FIX::Trailer *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Trailer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Trailer_removeGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Trailer_removeGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->removeGroup((FIX::Group const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trailer_removeGroup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Trailer_removeGroup", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Trailer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__Group, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Trailer_removeGroup__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Trailer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__Group, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Trailer_removeGroup__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Trailer_removeGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Trailer::removeGroup(unsigned int,FIX::Group const &)\n"
    "    FIX::Trailer::removeGroup(FIX::Group const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Trailer_hasGroup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Trailer *arg1 = (FIX::Trailer *) 0 ;
  FIX::Group *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Trailer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trailer_hasGroup" "', argument " "1"" of type '" "FIX::Trailer const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Trailer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Trailer_hasGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Trailer_hasGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Trailer const *)arg1)->hasGroup((FIX::Group const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trailer_hasGroup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Trailer *arg1 = (FIX::Trailer *) 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 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Trailer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trailer_hasGroup" "', argument " "1"" of type '" "FIX::Trailer const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Trailer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Trailer_hasGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Trailer_hasGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Trailer_hasGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Trailer const *)arg1)->hasGroup(arg2,(FIX::Group const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trailer_hasGroup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Trailer_hasGroup", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Trailer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__Group, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Trailer_hasGroup__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Trailer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__Group, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Trailer_hasGroup__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Trailer_hasGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Trailer::hasGroup(FIX::Group const &) const\n"
    "    FIX::Trailer::hasGroup(unsigned int,FIX::Group const &) const\n");
  return 0;
}


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


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

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

SWIGINTERN PyObject *_wrap_new_Message__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::Message *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Message *)new FIX::Message();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  message_order *arg1 = 0 ;
  message_order *arg2 = 0 ;
  message_order *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::Message *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  arg1 = reinterpret_cast< message_order * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Message" "', argument " "2"" of type '" "message_order const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "2"" of type '" "message_order const &""'"); 
  }
  arg2 = reinterpret_cast< message_order * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Message" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  arg3 = reinterpret_cast< message_order * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Message *)new FIX::Message((message_order const &)*arg1,(message_order const &)*arg2,(message_order const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  FIX::Message *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::Message *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Message *)new FIX::Message((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::DataDictionary *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  FIX::Message *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::DataDictionary *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FIX::Message *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::DataDictionary *arg2 = 0 ;
  FIX::DataDictionary *arg3 = 0 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  FIX::Message *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "3"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::DataDictionary * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2,(FIX::DataDictionary const &)*arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::DataDictionary *arg2 = 0 ;
  FIX::DataDictionary *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::Message *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "3"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::DataDictionary * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2,(FIX::DataDictionary const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  message_order *arg1 = 0 ;
  message_order *arg2 = 0 ;
  message_order *arg3 = 0 ;
  std::string *arg4 = 0 ;
  FIX::DataDictionary *arg5 = 0 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  FIX::Message *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  arg1 = reinterpret_cast< message_order * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Message" "', argument " "2"" of type '" "message_order const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "2"" of type '" "message_order const &""'"); 
  }
  arg2 = reinterpret_cast< message_order * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Message" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  arg3 = reinterpret_cast< message_order * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Message" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FIX__DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Message" "', argument " "5"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "5"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg5 = reinterpret_cast< FIX::DataDictionary * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Message" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Message *)new FIX::Message((message_order const &)*arg1,(message_order const &)*arg2,(message_order const &)*arg3,(std::string const &)*arg4,(FIX::DataDictionary const &)*arg5,arg6);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  message_order *arg1 = 0 ;
  message_order *arg2 = 0 ;
  message_order *arg3 = 0 ;
  std::string *arg4 = 0 ;
  FIX::DataDictionary *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  FIX::Message *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  arg1 = reinterpret_cast< message_order * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Message" "', argument " "2"" of type '" "message_order const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "2"" of type '" "message_order const &""'"); 
  }
  arg2 = reinterpret_cast< message_order * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Message" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  arg3 = reinterpret_cast< message_order * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Message" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FIX__DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Message" "', argument " "5"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "5"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg5 = reinterpret_cast< FIX::DataDictionary * >(argp5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Message *)new FIX::Message((message_order const &)*arg1,(message_order const &)*arg2,(message_order const &)*arg3,(std::string const &)*arg4,(FIX::DataDictionary const &)*arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  message_order *arg1 = 0 ;
  message_order *arg2 = 0 ;
  message_order *arg3 = 0 ;
  std::string *arg4 = 0 ;
  FIX::DataDictionary *arg5 = 0 ;
  FIX::DataDictionary *arg6 = 0 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  FIX::Message *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  arg1 = reinterpret_cast< message_order * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Message" "', argument " "2"" of type '" "message_order const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "2"" of type '" "message_order const &""'"); 
  }
  arg2 = reinterpret_cast< message_order * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Message" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  arg3 = reinterpret_cast< message_order * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Message" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FIX__DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Message" "', argument " "5"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "5"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg5 = reinterpret_cast< FIX::DataDictionary * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FIX__DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Message" "', argument " "6"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "6"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg6 = reinterpret_cast< FIX::DataDictionary * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Message" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Message *)new FIX::Message((message_order const &)*arg1,(message_order const &)*arg2,(message_order const &)*arg3,(std::string const &)*arg4,(FIX::DataDictionary const &)*arg5,(FIX::DataDictionary const &)*arg6,arg7);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  message_order *arg1 = 0 ;
  message_order *arg2 = 0 ;
  message_order *arg3 = 0 ;
  std::string *arg4 = 0 ;
  FIX::DataDictionary *arg5 = 0 ;
  FIX::DataDictionary *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  FIX::Message *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  arg1 = reinterpret_cast< message_order * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Message" "', argument " "2"" of type '" "message_order const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "2"" of type '" "message_order const &""'"); 
  }
  arg2 = reinterpret_cast< message_order * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Message" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  arg3 = reinterpret_cast< message_order * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Message" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FIX__DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Message" "', argument " "5"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "5"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg5 = reinterpret_cast< FIX::DataDictionary * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FIX__DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Message" "', argument " "6"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "6"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg6 = reinterpret_cast< FIX::DataDictionary * >(argp6);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Message *)new FIX::Message((message_order const &)*arg1,(message_order const &)*arg2,(message_order const &)*arg3,(std::string const &)*arg4,(FIX::DataDictionary const &)*arg5,(FIX::DataDictionary const &)*arg6);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Message *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "FIX::Message const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Message *)new FIX::Message((FIX::Message const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< FIX::Message > rvrdeleter1 ;
  FIX::Message *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__Message, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "FIX::Message &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "FIX::Message &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "FIX::Message &&""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Message *)new FIX::Message((FIX::Message &&)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Message", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Message__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__Message, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Message__SWIG_12(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Message__SWIG_13(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Message__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Message__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Message__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Message__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Message__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Message__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Message__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_Message__SWIG_9(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_Message__SWIG_11(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Message__SWIG_8(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_message_order, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_Message__SWIG_10(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Message'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::Message()\n"
    "    FIX::Message::Message(message_order const &,message_order const &,message_order const &)\n"
    "    FIX::Message::Message(std::string const &,bool)\n"
    "    FIX::Message::Message(std::string const &)\n"
    "    FIX::Message::Message(std::string const &,FIX::DataDictionary const &,bool)\n"
    "    FIX::Message::Message(std::string const &,FIX::DataDictionary const &)\n"
    "    FIX::Message::Message(std::string const &,FIX::DataDictionary const &,FIX::DataDictionary const &,bool)\n"
    "    FIX::Message::Message(std::string const &,FIX::DataDictionary const &,FIX::DataDictionary const &)\n"
    "    FIX::Message::Message(message_order const &,message_order const &,message_order const &,std::string const &,FIX::DataDictionary const &,bool)\n"
    "    FIX::Message::Message(message_order const &,message_order const &,message_order const &,std::string const &,FIX::DataDictionary const &)\n"
    "    FIX::Message::Message(message_order const &,message_order const &,message_order const &,std::string const &,FIX::DataDictionary const &,FIX::DataDictionary const &,bool)\n"
    "    FIX::Message::Message(message_order const &,message_order const &,message_order const &,std::string const &,FIX::DataDictionary const &,FIX::DataDictionary const &)\n"
    "    FIX::Message::Message(FIX::Message const &)\n"
    "    FIX::Message::Message(FIX::Message &&)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Message(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_InitializeXML(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "Message_InitializeXML" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Message::InitializeXML((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_addGroup(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Message_addGroup", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_addGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Message_addGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addGroup((FIX::Group const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_replaceGroup(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Message_replaceGroup", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &argp3, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message_replaceGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Message_replaceGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->replaceGroup(arg2,(FIX::Group const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getGroup(PyObject *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 *swig_obj[3] ;
  Group *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Message_getGroup", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "Message_getGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (Group *) &((FIX::Message const *)arg1)->getGroup(arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Group, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_removeGroup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &argp3, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message_removeGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Message_removeGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->removeGroup(arg2,(FIX::Group const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_removeGroup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_removeGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Message_removeGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->removeGroup((FIX::Group const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_Message_hasGroup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Message_hasGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Message const *)arg1)->hasGroup((FIX::Group const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_hasGroup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &argp3, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message_hasGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Message_hasGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Message const *)arg1)->hasGroup(arg2,(FIX::Group const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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(swig_obj[3], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::Message const *)arg1)->toString(arg2,arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::Message const *)arg1)->toString(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::Message const *)arg1)->toString(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::Message const *)arg1)->toString();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  std::string *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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*)PyUnicode_AsUTF8(swig_obj[1]));
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::Message const *)arg1)->toString(*arg2,arg3,arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  std::string *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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*)PyUnicode_AsUTF8(swig_obj[1]));
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &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(swig_obj[3], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::Message const *)arg1)->toString(*arg2,arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  std::string *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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*)PyUnicode_AsUTF8(swig_obj[1]));
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::Message const *)arg1)->toString(*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  std::string *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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*)PyUnicode_AsUTF8(swig_obj[1]));
    arg2 = &temp2;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::Message const *)arg1)->toString(*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Message_toString", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_toString__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_toString__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Message_toString__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Message_toString__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Message_toString__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Message_toString__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Message_toString__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Message_toString__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Message_toString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::toString(int,int,int) const\n"
    "    FIX::Message::toString(int,int) const\n"
    "    FIX::Message::toString(int) const\n"
    "    FIX::Message::toString() const\n"
    "    FIX::Message::toString(std::string &,int,int,int) const\n"
    "    FIX::Message::toString(std::string &,int,int) const\n"
    "    FIX::Message::toString(std::string &,int) const\n"
    "    FIX::Message::toString(std::string &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_toXML__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::Message const *)arg1)->toXML();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toXML__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  std::string *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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*)PyUnicode_AsUTF8(swig_obj[1]));
    arg2 = &temp2;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::Message const *)arg1)->toXML(*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_Message_reverseRoute(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Message_reverseRoute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__Header,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_reverseRoute" "', argument " "2"" of type '" "FIX::Header const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Message_reverseRoute" "', argument " "2"" of type '" "FIX::Header const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Header * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->reverseRoute((FIX::Header const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_setString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Message_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setString((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_setString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Message_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setString((std::string const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_setString__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Message_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &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(swig_obj[3], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setString((std::string const &)*arg2,arg3,(FIX::DataDictionary const *)arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_setString__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Message_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setString((std::string const &)*arg2,arg3,(FIX::DataDictionary const *)arg4,(FIX::DataDictionary const *)arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_setString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Message_setString", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_setString__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Message_setString__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Message_setString__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Message_setString__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Message_setString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::setString(std::string const &)\n"
    "    FIX::Message::setString(std::string const &,bool)\n"
    "    FIX::Message::setString(std::string const &,bool,FIX::DataDictionary const *)\n"
    "    FIX::Message::setString(std::string const &,bool,FIX::DataDictionary const *,FIX::DataDictionary const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_setGroup(PyObject *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 *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Message_setGroup", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Message_setGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "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(swig_obj[3], &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_NullReferenceError, "invalid null reference " "in method '" "Message_setGroup" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &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_NullReferenceError, "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(swig_obj[5], &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_NullReferenceError, "invalid null reference " "in method '" "Message_setGroup" "', argument " "6"" of type '" "FIX::FieldMap &""'"); 
  }
  arg6 = reinterpret_cast< FIX::FieldMap * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &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_NullReferenceError, "invalid null reference " "in method '" "Message_setGroup" "', argument " "7"" of type '" "DataDictionary const &""'"); 
  }
  arg7 = reinterpret_cast< DataDictionary * >(argp7);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        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;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_setStringHeader(PyObject *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 *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Message_setStringHeader", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Message_setStringHeader" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->setStringHeader((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getHeader__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Header *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Header *) &((FIX::Message const *)arg1)->getHeader();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Header, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getHeader__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Header *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Header *) &(arg1)->getHeader();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Header, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getHeader(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Message_getHeader", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getHeader__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getHeader__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Message_getHeader'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::getHeader() const\n"
    "    FIX::Message::getHeader()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_getTrailer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Trailer *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Trailer *) &((FIX::Message const *)arg1)->getTrailer();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Trailer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getTrailer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Trailer *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Trailer *) &(arg1)->getTrailer();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Trailer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getTrailer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Message_getTrailer", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getTrailer__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getTrailer__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Message_getTrailer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::getTrailer() const\n"
    "    FIX::Message::getTrailer()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_hasValidStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Message_hasValidStructure", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &temp2);
    arg2 = &temp2;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Message const *)arg1)->hasValidStructure(*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("int &") == "int &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyLong_FromLong(*arg2) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_bodyLength__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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(swig_obj[3], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::Message const *)arg1)->bodyLength(arg2,arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_bodyLength__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::Message const *)arg1)->bodyLength(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_bodyLength__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::Message const *)arg1)->bodyLength(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_bodyLength__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::Message const *)arg1)->bodyLength();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_bodyLength(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Message_bodyLength", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_bodyLength__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Message_bodyLength__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Message_bodyLength__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Message_bodyLength__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Message_bodyLength'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::bodyLength(int,int,int) const\n"
    "    FIX::Message::bodyLength(int,int) const\n"
    "    FIX::Message::bodyLength(int) const\n"
    "    FIX::Message::bodyLength() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_checkSum__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::Message const *)arg1)->checkSum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_checkSum__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::Message const *)arg1)->checkSum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_Message_isAdmin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Message const *)arg1)->isAdmin();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isApp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Message const *)arg1)->isApp();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->isEmpty();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->clear();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isAdminMsgType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MsgType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_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_NullReferenceError, "invalid null reference " "in method '" "Message_isAdminMsgType" "', argument " "1"" of type '" "MsgType const &""'"); 
  }
  arg1 = reinterpret_cast< MsgType * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Message::isAdminMsgType((MsgType const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toApplVerID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BeginString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ApplVerID result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "Message_toApplVerID" "', argument " "1"" of type '" "BeginString const &""'"); 
  }
  arg1 = reinterpret_cast< BeginString * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::Message::toApplVerID((BeginString const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new ApplVerID(result)), SWIGTYPE_p_ApplVerID, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toBeginString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ApplVerID *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BeginString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "Message_toBeginString" "', argument " "1"" of type '" "ApplVerID const &""'"); 
  }
  arg1 = reinterpret_cast< ApplVerID * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::Message::toBeginString((ApplVerID const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new BeginString(result)), SWIGTYPE_p_BeginString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isHeaderField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Message_isHeaderField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Message::isHeaderField(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isHeaderField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = 0 ;
  DataDictionary *arg2 = (DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_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_NullReferenceError, "invalid null reference " "in method '" "Message_isHeaderField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Message::isHeaderField((FIX::FieldBase const &)*arg1,(DataDictionary const *)arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isHeaderField__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_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_NullReferenceError, "invalid null reference " "in method '" "Message_isHeaderField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Message::isHeaderField((FIX::FieldBase const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isHeaderField__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  DataDictionary *arg2 = (DataDictionary *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Message::isHeaderField(arg1,(DataDictionary const *)arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isHeaderField(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Message_isHeaderField", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FieldBase, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_isHeaderField__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_Message_isHeaderField__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FieldBase, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_isHeaderField__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_isHeaderField__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Message_isHeaderField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::isHeaderField(int)\n"
    "    FIX::Message::isHeaderField(FIX::FieldBase const &,DataDictionary const *)\n"
    "    FIX::Message::isHeaderField(FIX::FieldBase const &)\n"
    "    FIX::Message::isHeaderField(int,DataDictionary const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_isTrailerField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Message_isTrailerField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Message::isTrailerField(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isTrailerField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = 0 ;
  DataDictionary *arg2 = (DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_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_NullReferenceError, "invalid null reference " "in method '" "Message_isTrailerField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Message::isTrailerField((FIX::FieldBase const &)*arg1,(DataDictionary const *)arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isTrailerField__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_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_NullReferenceError, "invalid null reference " "in method '" "Message_isTrailerField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Message::isTrailerField((FIX::FieldBase const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isTrailerField__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  DataDictionary *arg2 = (DataDictionary *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Message::isTrailerField(arg1,(DataDictionary const *)arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isTrailerField(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Message_isTrailerField", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FieldBase, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_isTrailerField__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_Message_isTrailerField__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FieldBase, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_isTrailerField__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_isTrailerField__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Message_isTrailerField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::isTrailerField(int)\n"
    "    FIX::Message::isTrailerField(FIX::FieldBase const &,DataDictionary const *)\n"
    "    FIX::Message::isTrailerField(FIX::FieldBase const &)\n"
    "    FIX::Message::isTrailerField(int,DataDictionary const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_getSessionID__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SessionID result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Message_getSessionID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::Message const *)arg1)->getSessionID((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getSessionID__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SessionID result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::Message const *)arg1)->getSessionID();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new SessionID(result)), SWIGTYPE_p_SessionID, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getSessionID(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Message_getSessionID", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getSessionID__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_getSessionID__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Message_getSessionID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::getSessionID(std::string const &) const\n"
    "    FIX::Message::getSessionID() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_setSessionID(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Message_setSessionID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Message_setSessionID" "', argument " "2"" of type '" "SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setSessionID((SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX_Message___str__(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  FIX::Message *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::ostream *) &FIX::operator <<(*arg1,(FIX::Message const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_identifyType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  MsgType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "identifyType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::identifyType((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new 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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Group__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::Group *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Group *)new FIX::Group(arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Group, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Group__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int *arg3 = (int *) (int *)0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::Group *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Group *)new FIX::Group(arg1,arg2,(int const (*))arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Group, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Group__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  message_order *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::Group *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "new_Group" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  arg3 = reinterpret_cast< message_order * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Group *)new FIX::Group(arg1,arg2,(message_order const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Group, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Group__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Group *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_Group" "', argument " "1"" of type '" "FIX::Group const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Group *)new FIX::Group((FIX::Group const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Group, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Group(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Group", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__Group, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Group__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Group__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      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, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Group__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Group__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Group'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Group::Group(int,int)\n"
    "    FIX::Group::Group(int,int,int const [])\n"
    "    FIX::Group::Group(int,int,message_order const &)\n"
    "    FIX::Group::Group(FIX::Group const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Group_field(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::Group const *)arg1)->field();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_delim(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::Group const *)arg1)->delim();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_addGroup(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Group_addGroup", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_addGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Group_addGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addGroup((FIX::Group const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_replaceGroup(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Group_replaceGroup", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &argp3, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Group_replaceGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Group_replaceGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->replaceGroup(arg2,(FIX::Group const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_getGroup(PyObject *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 *swig_obj[3] ;
  FIX::Group *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Group_getGroup", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "Group_getGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Group *) &((FIX::Group const *)arg1)->getGroup(arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Group, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_removeGroup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &argp3, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Group_removeGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Group_removeGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->removeGroup(arg2,(FIX::Group const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_removeGroup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_removeGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Group_removeGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->removeGroup((FIX::Group const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_Group_hasGroup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Group_hasGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->hasGroup((FIX::Group const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_hasGroup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &argp3, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Group_hasGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Group_hasGroup" "', argument " "3"" of type '" "FIX::Group const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->hasGroup(arg2,(FIX::Group const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_delete_Group(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_BeginString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::BeginString *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::BeginString *)new FIX::BeginString();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BeginString, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BeginString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::BeginString *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BeginString" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_BeginString" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::BeginString *)new FIX::BeginString((FIX::STRING const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BeginString, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("FIX::STRING const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BeginString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BeginString", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_BeginString__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BeginString__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BeginString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BeginString::BeginString()\n"
    "    FIX::BeginString::BeginString(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BeginString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BeginString *arg1 = (FIX::BeginString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SenderCompID__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::SenderCompID *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SenderCompID *)new FIX::SenderCompID();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SenderCompID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SenderCompID__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::SenderCompID *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SenderCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SenderCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SenderCompID *)new FIX::SenderCompID((FIX::STRING const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SenderCompID, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("FIX::STRING const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SenderCompID(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SenderCompID", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SenderCompID__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SenderCompID__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SenderCompID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SenderCompID::SenderCompID()\n"
    "    FIX::SenderCompID::SenderCompID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SenderCompID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SenderCompID *arg1 = (FIX::SenderCompID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_TargetCompID__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::TargetCompID *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::TargetCompID *)new FIX::TargetCompID();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetCompID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetCompID__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::TargetCompID *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TargetCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_TargetCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::TargetCompID *)new FIX::TargetCompID((FIX::STRING const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetCompID, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("FIX::STRING const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetCompID(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TargetCompID", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TargetCompID__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetCompID__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TargetCompID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TargetCompID::TargetCompID()\n"
    "    FIX::TargetCompID::TargetCompID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TargetCompID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetCompID *arg1 = (FIX::TargetCompID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

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


SWIGINTERN PyObject *Swig_var_BeginString_FIXT11_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIXT11);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_BeginString_FIX50_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX50);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_BeginString_FIX44_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX44);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_BeginString_FIX43_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX43);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_BeginString_FIX42_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX42);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_BeginString_FIX41_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX41);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_BeginString_FIX40_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX40);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_INVALID_TAG_NUMBER_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_REQUIRED_TAG_MISSING_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_UNDEFINED_TAG_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_UNDEFINED_TAG_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_VALUE_IS_INCORRECT_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_DECRYPTION_PROBLEM_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_SIGNATURE_PROBLEM_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_COMPID_PROBLEM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_COMPID_PROBLEM_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INVALID_MSGTYPE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_INVALID_MSGTYPE_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_OTHER_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_OTHER_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_UNKNOWN_ID_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNKNOWN_ID_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNKNOWN_SECURITY_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_NOT_AUTHORIZED_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_NOT_AUTHORIZED_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_DELIVER_TO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_DELIVER_TO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_Heartbeat_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Heartbeat);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_TestRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TestRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ResendRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ResendRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_Reject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Reject);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SequenceReset_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SequenceReset);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_Logout_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Logout);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_Logon_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Logon);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_XMLnonFIX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_XMLnonFIX);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_IOI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_IOI);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_Advertisement_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Advertisement);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ExecutionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ExecutionReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_OrderCancelReject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderCancelReject);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_News_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_News);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_Email_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Email);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_NewOrderSingle_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NewOrderSingle);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_NewOrderList_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NewOrderList);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_OrderCancelRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderCancelRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_OrderCancelReplaceRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderCancelReplaceRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_OrderStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderStatusRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_Allocation_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Allocation);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ListCancelRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListCancelRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ListExecute_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListExecute);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ListStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListStatusRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ListStatus_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListStatus);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_AllocationInstructionAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationInstructionAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_DontKnowTrade_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_DontKnowTrade);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_QuoteRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_Quote_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Quote);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SettlementInstructions_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SettlementInstructions);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MarketDataRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MarketDataSnapshotFullRefresh_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataSnapshotFullRefresh);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MarketDataIncrementalRefresh_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataIncrementalRefresh);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MarketDataRequestReject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataRequestReject);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_QuoteCancel_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteCancel);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_QuoteStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteStatusRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_QuoteAcknowledgement_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteAcknowledgement);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SecurityDefinitionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinitionRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SecurityDefinition_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinition);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SecurityStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityStatusRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SecurityStatus_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityStatus);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_TradingSessionStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionStatusRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_TradingSessionStatus_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionStatus);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MassQuote_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MassQuote);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_BusinessMessageReject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_BusinessMessageReject);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_BidRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_BidRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_BidResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_BidResponse);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ListStrikePrice_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListStrikePrice);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_AllocationAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MassQuoteAcknowledgement_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MassQuoteAcknowledgement);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_RegistrationInstructions_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RegistrationInstructions);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_RegistrationInstructionsResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RegistrationInstructionsResponse);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_OrderMassCancelRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassCancelRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_OrderMassCancelReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassCancelReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_NewOrderCross_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NewOrderCross);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_CrossOrderCancelReplaceRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CrossOrderCancelReplaceRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_CrossOrderCancelRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CrossOrderCancelRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SecurityTypeRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityTypeRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SecurityTypes_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityTypes);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SecurityListRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityListRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SecurityList_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityList);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_DerivativeSecurityListRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityListRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_DerivativeSecurityList_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityList);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_NewOrderMultileg_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NewOrderMultileg);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MultilegOrderCancelReplaceRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MultilegOrderCancelReplaceRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_TradeCaptureReportRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_TradeCaptureReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_OrderMassStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassStatusRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_QuoteRequestReject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteRequestReject);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_RFQRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RFQRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_QuoteStatusReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteStatusReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_AllocationInstruction_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationInstruction);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MultilegOrderCancelReplace_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MultilegOrderCancelReplace);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_QuoteResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteResponse);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_Confirmation_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Confirmation);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PositionMaintenanceRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PositionMaintenanceRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PositionMaintenanceReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PositionMaintenanceReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_RequestForPositions_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RequestForPositions);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_RequestForPositionsAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RequestForPositionsAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PositionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PositionReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_TradeCaptureReportRequestAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportRequestAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_TradeCaptureReportAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_AllocationReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_AllocationReportAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationReportAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ConfirmationAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ConfirmationAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SettlementInstructionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SettlementInstructionRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_AssignmentReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AssignmentReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_CollateralRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_CollateralAssignment_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralAssignment);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_CollateralResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralResponse);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_CollateralReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_CollateralInquiry_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralInquiry);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_NetworkCounterpartySystemStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NetworkCounterpartySystemStatusRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_NetworkCounterpartySystemStatusResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NetworkCounterpartySystemStatusResponse);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_UserRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_UserRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_UserResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_UserResponse);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_CollateralInquiryAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralInquiryAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ConfirmationRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ConfirmationRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ContraryIntentionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ContraryIntentionReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SecurityDefinitionUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinitionUpdateReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SecurityListUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityListUpdateReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_AdjustedPositionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AdjustedPositionReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_AllocationInstructionAlert_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationInstructionAlert);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ExecutionAcknowledgement_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ExecutionAcknowledgement);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_TradingSessionList_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionList);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_TradingSessionListRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionListRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SettlementObligationReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SettlementObligationReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_DerivativeSecurityListUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityListUpdateReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_TradingSessionListUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionListUpdateReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MarketDefinitionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDefinitionRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MarketDefinition_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDefinition);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MarketDefinitionUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDefinitionUpdateReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_UserNotification_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_UserNotification);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_OrderMassActionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassActionReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_OrderMassActionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassActionRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ApplicationMessageRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ApplicationMessageRequestAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageRequestAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ApplicationMessageReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MassQuoteAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MassQuoteAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_ExecutionAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ExecutionAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_StreamAssignmentRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_StreamAssignmentReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_StreamAssignmentReportACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentReportACK);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MarginRequirementInquiry_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarginRequirementInquiry);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MarginRequirementInquiryAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarginRequirementInquiryAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MarginRequirementReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarginRequirementReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyDetailsListRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyDetailsListRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyDetailsListReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyDetailsListReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyDetailsListUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyDetailsListUpdateReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyRiskLimitsRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyRiskLimitsRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyRiskLimitsReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyRiskLimitsReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SecurityMassStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityMassStatusRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_SecurityMassStatus_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityMassStatus);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_AccountSummaryReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AccountSummaryReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyRiskLimitsUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyRiskLimitsUpdateReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyRiskLimitsDefinitionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyRiskLimitsDefinitionRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyRiskLimitsDefinitionRequestAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyRiskLimitsDefinitionRequestAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyEntitlementsRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyEntitlementsRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyEntitlementsReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyEntitlementsReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_QuoteAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyDetailsDefinitionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyDetailsDefinitionRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyDetailsDefinitionRequestAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyDetailsDefinitionRequestAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyEntitlementsUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyEntitlementsUpdateReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyEntitlementsDefinitionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyEntitlementsDefinitionRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyEntitlementsDefinitionRequestAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyEntitlementsDefinitionRequestAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_TradeMatchReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeMatchReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_TradeMatchReportAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeMatchReportAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyRiskLimitsReportAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyRiskLimitsReportAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyRiskLimitCheckRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyRiskLimitCheckRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyRiskLimitCheckRequestAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyRiskLimitCheckRequestAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyActionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyActionRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PartyActionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyActionReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MassOrder_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MassOrder);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MassOrderAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MassOrderAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PositionTransferInstruction_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PositionTransferInstruction);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PositionTransferInstructionAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PositionTransferInstructionAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_PositionTransferReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PositionTransferReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MarketDataStatisticsRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataStatisticsRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MarketDataStatisticsReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataStatisticsReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_CollateralReportAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralReportAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_MarketDataReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataReport);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_CrossRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CrossRequest);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_CrossRequestAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CrossRequestAck);
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var_MsgType_AllocationInstructionAlertRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationInstructionAlertRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_AllocationInstructionAlertRequestAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AllocationInstructionAlertRequestAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_AllocationInstructionAlertRequestAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationInstructionAlertRequestAck);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_TradeAggregationRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradeAggregationRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_TradeAggregationRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeAggregationRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_TradeAggregationReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradeAggregationReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_TradeAggregationReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeAggregationReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_PayManagementReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_PayManagementReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_PayManagementReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PayManagementReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_PayManagementReportAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_PayManagementReportAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_PayManagementReportAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PayManagementReportAck);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_PayManagementRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_PayManagementRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_PayManagementRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PayManagementRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_PayManagementRequestAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_PayManagementRequestAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_PayManagementRequestAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PayManagementRequestAck);
  return pyobj;
}


SWIGINTERN int Swig_var_PossDupFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PossDupFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PossDupFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PossDupFlag_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_PossDupFlag_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PossDupFlag_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PossDupFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PossDupFlag_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_PossResend_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PossResend_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PossResend_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PossResend_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_PossResend_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PossResend_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PossResend_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PossResend_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_NONE_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_NONE_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_NONE_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_NONE_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_PKCS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_PKCS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_PKCS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PKCS));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_DES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_DES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_DES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_DES));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_PKCSDES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_PKCSDES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_PKCSDES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PKCSDES));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_PGPDES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_PGPDES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_PGPDES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PGPDES));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_PGPDESMD5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_PGPDESMD5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_PGPDESMD5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PGPDESMD5));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_PEMDESMD5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_PEMDESMD5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_PEMDESMD5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PEMDESMD5));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_PEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_PEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_PEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PEM));
  return pyobj;
}


SWIGINTERN int Swig_var_GapFillFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GapFillFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GapFillFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::GapFillFlag_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_GapFillFlag_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GapFillFlag_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GapFillFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::GapFillFlag_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_ResetSeqNumFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResetSeqNumFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ResetSeqNumFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ResetSeqNumFlag_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_ResetSeqNumFlag_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResetSeqNumFlag_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ResetSeqNumFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ResetSeqNumFlag_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_MessageEncoding_EUCJP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_EUCJP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MessageEncoding_EUCJP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_EUCJP);
  return pyobj;
}


SWIGINTERN int Swig_var_MessageEncoding_ISO2022_JP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_ISO2022_JP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MessageEncoding_ISO2022_JP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_ISO2022_JP);
  return pyobj;
}


SWIGINTERN int Swig_var_MessageEncoding_SHIFT_JIS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_SHIFT_JIS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MessageEncoding_SHIFT_JIS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_SHIFT_JIS);
  return pyobj;
}


SWIGINTERN int Swig_var_MessageEncoding_UTF8_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_UTF8 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MessageEncoding_UTF8_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_UTF8);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INVALID_TAG_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INVALID_TAG_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_REQUIRED_TAG_MISSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_REQUIRED_TAG_MISSING));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_UNDEFINED_TAG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_UNDEFINED_TAG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_UNDEFINED_TAG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_UNDEFINED_TAG));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_VALUE_IS_INCORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_VALUE_IS_INCORRECT));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_DECRYPTION_PROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_DECRYPTION_PROBLEM));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_SIGNATURE_PROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_SIGNATURE_PROBLEM));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_COMPID_PROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_COMPID_PROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_COMPID_PROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_COMPID_PROBLEM));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INVALID_MSGTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INVALID_MSGTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INVALID_MSGTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INVALID_MSGTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_XML_VALIDATION_ERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_XML_VALIDATION_ERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_XML_VALIDATION_ERROR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_XML_VALIDATION_ERROR));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INVALID_UNSUPPORTED_APPLICATION_VERSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INVALID_UNSUPPORTED_APPLICATION_VERSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INVALID_UNSUPPORTED_APPLICATION_VERSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INVALID_UNSUPPORTED_APPLICATION_VERSION));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_SENDING_TIME_ACCURACY_PROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_SENDING_TIME_ACCURACY_PROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_SENDING_TIME_ACCURACY_PROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_SENDING_TIME_ACCURACY_PROBLEM));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INVALID_MSG_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INVALID_MSG_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INVALID_MSG_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INVALID_MSG_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_COMP_ID_PROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_COMP_ID_PROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_COMP_ID_PROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_COMP_ID_PROBLEM));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_NON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_NON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_NON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_NON));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INCORRECT_NUM_IN_GROUP_COUNT_FOR_REPEATING_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INCORRECT_NUM_IN_GROUP_COUNT_FOR_REPEATING_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INCORRECT_NUM_IN_GROUP_COUNT_FOR_REPEATING_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INCORRECT_NUM_IN_GROUP_COUNT_FOR_REPEATING_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_TestMessageIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TestMessageIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TestMessageIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TestMessageIndicator_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_TestMessageIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TestMessageIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TestMessageIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TestMessageIndicator_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX27_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX27 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX27_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX27);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX30_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX30 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX30_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX30);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX40_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX40 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX40_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX40);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX41_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX41 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX41_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX41);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX42_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX42 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX42_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX42);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX43_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX43 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX43_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX43);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX44_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX44 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX44_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX44);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX50_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX50 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX50_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX50);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX50_SP1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX50_SP1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX50_SP1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX50_SP1);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX50_SP2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX50_SP2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX50_SP2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX50_SP2);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_SESSION_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_SESSION_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_SESSION_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_SESSION_ACTIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_SESSION_PASSWORD_CHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_SESSION_PASSWORD_CHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_SESSION_PASSWORD_CHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_SESSION_PASSWORD_CHANGED));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_SESSION_LOGOUT_COMPLETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_SESSION_LOGOUT_COMPLETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_SESSION_LOGOUT_COMPLETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_SESSION_LOGOUT_COMPLETE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_INVALID_USERNAME_OR_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_INVALID_USERNAME_OR_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_INVALID_USERNAME_OR_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_INVALID_USERNAME_OR_PASSWORD));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_ACCOUNT_LOCKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_ACCOUNT_LOCKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_ACCOUNT_LOCKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_ACCOUNT_LOCKED));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_PASSWORD_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_PASSWORD_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_PASSWORD_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_PASSWORD_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_AdvSide_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvSide_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdvSide_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AdvSide_BUY));
  return pyobj;
}


SWIGINTERN int Swig_var_AdvSide_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvSide_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdvSide_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AdvSide_SELL));
  return pyobj;
}


SWIGINTERN int Swig_var_AdvSide_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvSide_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdvSide_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AdvSide_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_AdvSide_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvSide_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdvSide_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AdvSide_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_AdvTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdvTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::AdvTransType_CANCEL);
  return pyobj;
}


SWIGINTERN int Swig_var_AdvTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdvTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::AdvTransType_NEW);
  return pyobj;
}


SWIGINTERN int Swig_var_AdvTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdvTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::AdvTransType_REPLACE);
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_PER_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PER_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_PER_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PER_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_ABSOLUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_ABSOLUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_ABSOLUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_ABSOLUTE));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_POINTS_PER_BOND_OR_CONTRACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_POINTS_PER_BOND_OR_CONTRACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_POINTS_PER_BOND_OR_CONTRACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_POINTS_PER_BOND_OR_CONTRACT));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_PERCENTAGE_WAIVED_ENHANCED_UNITS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PERCENTAGE_WAIVED_ENHANCED_UNITS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_PERCENTAGE_WAIVED_ENHANCED_UNITS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENTAGE_WAIVED_ENHANCED_UNITS));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_PERCENTAGE_WAIVED_CASH_DISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PERCENTAGE_WAIVED_CASH_DISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_PERCENTAGE_WAIVED_CASH_DISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENTAGE_WAIVED_CASH_DISCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_BASIS_POINTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_BASIS_POINTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_BASIS_POINTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_BASIS_POINTS));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_AMOUNT_PER_CONTRACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_AMOUNT_PER_CONTRACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_AMOUNT_PER_CONTRACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_AMOUNT_PER_CONTRACT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_STAY_ON_OFFER_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STAY_ON_OFFER_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_STAY_ON_OFFER_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAY_ON_OFFER_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NOT_HELD));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_WORK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_WORK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_WORK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_WORK));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_GO_ALONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_GO_ALONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_GO_ALONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_GO_ALONG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_OVER_THE_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OVER_THE_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_OVER_THE_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_OVER_THE_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_HELD));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_PARTICIPATE_DO_NOT_INITIATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PARTICIPATE_DO_NOT_INITIATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_PARTICIPATE_DO_NOT_INITIATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PARTICIPATE_DO_NOT_INITIATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_STRICT_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STRICT_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_STRICT_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICT_SCALE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_TRY_TO_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRY_TO_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_TRY_TO_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRY_TO_SCALE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_STAY_ON_BID_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STAY_ON_BID_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_STAY_ON_BID_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAY_ON_BID_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_NO_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NO_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_NO_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NO_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_OK_TO_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OK_TO_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_OK_TO_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_OK_TO_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CALL_FIRST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CALL_FIRST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CALL_FIRST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CALL_FIRST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_PERCENT_OF_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PERCENT_OF_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_PERCENT_OF_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PERCENT_OF_VOLUME));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_DO_NOT_INCREASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_DO_NOT_INCREASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_DO_NOT_INCREASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_DO_NOT_INCREASE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_DO_NOT_REDUCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_DO_NOT_REDUCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_DO_NOT_REDUCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_DO_NOT_REDUCE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_ALL_OR_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_ALL_OR_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_INSTITUTIONS_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_INSTITUTIONS_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_INSTITUTIONS_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_INSTITUTIONS_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_LAST_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_LAST_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_LAST_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_LAST_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_MID_PRICE_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_MID_PRICE_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_MID_PRICE_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_MID_PRICE_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_NON_NEGOTIABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NON_NEGOTIABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_NON_NEGOTIABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NON_NEGOTIABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_OPENING_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OPENING_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_OPENING_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_OPENING_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_MARKET_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_MARKET_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_MARKET_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_MARKET_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_PRIMARY_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PRIMARY_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_PRIMARY_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PRIMARY_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_SUSPEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_SUSPEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_SUSPEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_SUSPEND));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CUSTOMER_DISPLAY_INSTRUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CUSTOMER_DISPLAY_INSTRUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CUSTOMER_DISPLAY_INSTRUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CUSTOMER_DISPLAY_INSTRUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NETTING));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_PEG_TO_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PEG_TO_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_PEG_TO_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PEG_TO_VWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_TRY_TO_STOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRY_TO_STOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_TRY_TO_STOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRY_TO_STOP));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CANCEL_ON_SYSTEM_FAILURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCEL_ON_SYSTEM_FAILURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CANCEL_ON_SYSTEM_FAILURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCEL_ON_SYSTEM_FAILURE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_TRADE_ALONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRADE_ALONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_TRADE_ALONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRADE_ALONG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_REINSTATE_ON_SYSTEM_FAILURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_REINSTATE_ON_SYSTEM_FAILURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_REINSTATE_ON_SYSTEM_FAILURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_REINSTATE_ON_SYSTEM_FAILURE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_REINSTATE_ON_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_REINSTATE_ON_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_REINSTATE_ON_TRADING_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_REINSTATE_ON_TRADING_HALT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CANCEL_ON_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCEL_ON_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CANCEL_ON_TRADING_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCEL_ON_TRADING_HALT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CANCEL_IF_NOT_BEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCEL_IF_NOT_BEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CANCEL_IF_NOT_BEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCEL_IF_NOT_BEST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_TRAILING_STOP_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRAILING_STOP_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_TRAILING_STOP_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRAILING_STOP_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_STRICT_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STRICT_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_STRICT_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICT_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_IGNORE_PRICE_VALIDITY_CHECKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_IGNORE_PRICE_VALIDITY_CHECKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_IGNORE_PRICE_VALIDITY_CHECKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_IGNORE_PRICE_VALIDITY_CHECKS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_PEG_TO_LIMIT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PEG_TO_LIMIT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_PEG_TO_LIMIT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PEG_TO_LIMIT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_WORK_TO_TARGET_STRATEGY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_WORK_TO_TARGET_STRATEGY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_WORK_TO_TARGET_STRATEGY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_WORK_TO_TARGET_STRATEGY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_INTERMARKET_SWEEP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_INTERMARKET_SWEEP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_INTERMARKET_SWEEP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_INTERMARKET_SWEEP));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_EXTERNAL_ROUTING_ALLOWED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_EXTERNAL_ROUTING_ALLOWED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_EXTERNAL_ROUTING_ALLOWED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXTERNAL_ROUTING_ALLOWED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_IMBALANCE_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_IMBALANCE_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_IMBALANCE_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_IMBALANCE_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_BEST_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_BEST_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_BEST_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_BEST_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_SUSPEND_ON_SYSTEM_FAILURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_SUSPEND_ON_SYSTEM_FAILURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_SUSPEND_ON_SYSTEM_FAILURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_SUSPEND_ON_SYSTEM_FAILURE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_SUSPEND_ON_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_SUSPEND_ON_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_SUSPEND_ON_TRADING_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_SUSPEND_ON_TRADING_HALT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_REINSTATE_ON_CONNECTION_LOSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_REINSTATE_ON_CONNECTION_LOSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_REINSTATE_ON_CONNECTION_LOSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_REINSTATE_ON_CONNECTION_LOSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CANCEL_ON_CONNECTION_LOSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCEL_ON_CONNECTION_LOSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CANCEL_ON_CONNECTION_LOSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCEL_ON_CONNECTION_LOSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_SUSPEND_ON_CONNECTION_LOSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_SUSPEND_ON_CONNECTION_LOSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_SUSPEND_ON_CONNECTION_LOSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_SUSPEND_ON_CONNECTION_LOSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_RELEASE_FROM_SUSPENSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_RELEASE_FROM_SUSPENSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_RELEASE_FROM_SUSPENSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_RELEASE_FROM_SUSPENSION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_EXECUTE_AS_DELTA_NEUTRAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_EXECUTE_AS_DELTA_NEUTRAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_EXECUTE_AS_DELTA_NEUTRAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXECUTE_AS_DELTA_NEUTRAL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_EXECUTE_AS_DURATION_NEUTRAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_EXECUTE_AS_DURATION_NEUTRAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_EXECUTE_AS_DURATION_NEUTRAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXECUTE_AS_DURATION_NEUTRAL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_EXECUTE_AS_FX_NEUTRAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_EXECUTE_AS_FX_NEUTRAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_EXECUTE_AS_FX_NEUTRAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXECUTE_AS_FX_NEUTRAL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_RELEASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_RELEASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_RELEASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_RELEASE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_MIN_GUARANTEED_FILL_ELIGIBLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_MIN_GUARANTEED_FILL_ELIGIBLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_MIN_GUARANTEED_FILL_ELIGIBLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_MIN_GUARANTEED_FILL_ELIGIBLE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_BYPASS_NON_DISPLAY_LIQUIDITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_BYPASS_NON_DISPLAY_LIQUIDITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_BYPASS_NON_DISPLAY_LIQUIDITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_BYPASS_NON_DISPLAY_LIQUIDITY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_LOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_LOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_LOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_LOCK));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_IGNORE_NOTIONAL_VALUE_CHECKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_IGNORE_NOTIONAL_VALUE_CHECKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_IGNORE_NOTIONAL_VALUE_CHECKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_IGNORE_NOTIONAL_VALUE_CHECKS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_TRD_AT_REF_PX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRD_AT_REF_PX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_TRD_AT_REF_PX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRD_AT_REF_PX));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_ALLOW_FACILITATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_ALLOW_FACILITATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_ALLOW_FACILITATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_ALLOW_FACILITATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTransType_CORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTransType_CORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTransType_CORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecTransType_CORRECT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTransType_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTransType_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTransType_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecTransType_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_HandlInst_AUTOMATED_EXECUTION_NO_INTERVENTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HandlInst_AUTOMATED_EXECUTION_NO_INTERVENTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HandlInst_AUTOMATED_EXECUTION_NO_INTERVENTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HandlInst_AUTOMATED_EXECUTION_NO_INTERVENTION));
  return pyobj;
}


SWIGINTERN int Swig_var_HandlInst_AUTOMATED_EXECUTION_INTERVENTION_OK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HandlInst_AUTOMATED_EXECUTION_INTERVENTION_OK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HandlInst_AUTOMATED_EXECUTION_INTERVENTION_OK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HandlInst_AUTOMATED_EXECUTION_INTERVENTION_OK));
  return pyobj;
}


SWIGINTERN int Swig_var_HandlInst_MANUAL_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HandlInst_MANUAL_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HandlInst_MANUAL_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HandlInst_MANUAL_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_CUSIP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_CUSIP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_CUSIP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_CUSIP);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_SEDOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_SEDOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_SEDOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_SEDOL);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_QUIK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_QUIK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_QUIK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_QUIK);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_ISIN_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_ISIN_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_ISIN_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_ISIN_NUMBER);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_RIC_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_RIC_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_RIC_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_RIC_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_ISO_CURRENCY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_ISO_CURRENCY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_ISO_CURRENCY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_ISO_CURRENCY_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_ISO_COUNTRY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_ISO_COUNTRY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_ISO_COUNTRY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_ISO_COUNTRY_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_EXCHANGE_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_EXCHANGE_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_EXCHANGE_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_EXCHANGE_SYMBOL);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_CONSOLIDATED_TAPE_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_CONSOLIDATED_TAPE_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_CONSOLIDATED_TAPE_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_CONSOLIDATED_TAPE_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int Swig_var_IOIOthSvc_AUTEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIOthSvc_AUTEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIOthSvc_AUTEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIOthSvc_AUTEX));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIOthSvc_BRIDGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIOthSvc_BRIDGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIOthSvc_BRIDGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIOthSvc_BRIDGE));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQltyInd_HIGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQltyInd_HIGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQltyInd_HIGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_HIGH));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQltyInd_LOW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQltyInd_LOW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQltyInd_LOW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_LOW));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQltyInd_MEDIUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQltyInd_MEDIUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQltyInd_MEDIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_MEDIUM));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIShares_LARGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIShares_LARGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIShares_LARGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIShares_LARGE);
  return pyobj;
}


SWIGINTERN int Swig_var_IOIShares_MEDIUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIShares_MEDIUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIShares_MEDIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIShares_MEDIUM);
  return pyobj;
}


SWIGINTERN int Swig_var_IOIShares_SMALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIShares_SMALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIShares_SMALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIShares_SMALL);
  return pyobj;
}


SWIGINTERN int Swig_var_IOITransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOITransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOITransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOITransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_IOITransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOITransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOITransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOITransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_IOITransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOITransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOITransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOITransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_LastCapacity_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastCapacity_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_AGENT));
  return pyobj;
}


SWIGINTERN int Swig_var_LastCapacity_CROSS_AS_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_CROSS_AS_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastCapacity_CROSS_AS_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_CROSS_AS_AGENT));
  return pyobj;
}


SWIGINTERN int Swig_var_LastCapacity_CROSS_AS_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_CROSS_AS_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastCapacity_CROSS_AS_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_CROSS_AS_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_LastCapacity_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastCapacity_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_LastCapacity_RISKLESS_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_RISKLESS_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastCapacity_RISKLESS_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_RISKLESS_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_PARTIALLY_FILLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PARTIALLY_FILLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_PARTIALLY_FILLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PARTIALLY_FILLED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_FILLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_FILLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_FILLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_FILLED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_DONE_FOR_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_DONE_FOR_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_DONE_FOR_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_DONE_FOR_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_CANCELED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_CANCELED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_CANCELED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_CANCELED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_REPLACED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_REPLACED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_REPLACED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_REPLACED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_PENDING_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PENDING_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_PENDING_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_STOPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_STOPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_STOPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_STOPPED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_SUSPENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_SUSPENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_SUSPENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_SUSPENDED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_PENDING_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PENDING_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_PENDING_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_CALCULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_CALCULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_CALCULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_CALCULATED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_ACCEPTED_FOR_BIDDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_ACCEPTED_FOR_BIDDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_ACCEPTED_FOR_BIDDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_ACCEPTED_FOR_BIDDING));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_PENDING_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PENDING_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_PENDING_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_STOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_STOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_STOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_STOP));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_STOP_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_STOP_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_STOP_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_STOP_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_MARKET_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKET_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_MARKET_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET_ON_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_WITH_OR_WITHOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_WITH_OR_WITHOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_WITH_OR_WITHOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_WITH_OR_WITHOUT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_LIMIT_OR_BETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMIT_OR_BETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_LIMIT_OR_BETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMIT_OR_BETTER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_LIMIT_WITH_OR_WITHOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMIT_WITH_OR_WITHOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_LIMIT_WITH_OR_WITHOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMIT_WITH_OR_WITHOUT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_ON_BASIS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_ON_BASIS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_ON_BASIS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_ON_BASIS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_ON_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_LIMIT_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMIT_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_LIMIT_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMIT_ON_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FOREX_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FOREX_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_PREVIOUSLY_QUOTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PREVIOUSLY_QUOTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_PREVIOUSLY_QUOTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSLY_QUOTED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_PREVIOUSLY_INDICATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PREVIOUSLY_INDICATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_PREVIOUSLY_INDICATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSLY_INDICATED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_PEGGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PEGGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_PEGGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_PEGGED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FOREX_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FOREX_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FOREX_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FOREX_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_SWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FOREX_PREVIOUSLY_QUOTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_PREVIOUSLY_QUOTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FOREX_PREVIOUSLY_QUOTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_PREVIOUSLY_QUOTED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FUNARI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FUNARI is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FUNARI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FUNARI));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_MARKET_IF_TOUCHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKET_IF_TOUCHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_MARKET_IF_TOUCHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET_IF_TOUCHED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_PREVIOUS_FUND_VALUATION_POINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PREVIOUS_FUND_VALUATION_POINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_PREVIOUS_FUND_VALUATION_POINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUS_FUND_VALUATION_POINT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_NEXT_FUND_VALUATION_POINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_NEXT_FUND_VALUATION_POINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_NEXT_FUND_VALUATION_POINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_NEXT_FUND_VALUATION_POINT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_COUNTER_ORDER_SELECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_COUNTER_ORDER_SELECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_COUNTER_ORDER_SELECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_COUNTER_ORDER_SELECTION));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_STOP_ON_BID_OR_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_STOP_ON_BID_OR_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_STOP_ON_BID_OR_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_STOP_ON_BID_OR_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_STOP_LIMIT_ON_BID_OR_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_STOP_LIMIT_ON_BID_OR_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_STOP_LIMIT_ON_BID_OR_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_STOP_LIMIT_ON_BID_OR_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_AGENCY_SINGLE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_AGENCY_SINGLE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_AGENCY_SINGLE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENCY_SINGLE_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PROPRIETARY_NON_ALGO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROPRIETARY_NON_ALGO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PROPRIETARY_NON_ALGO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROPRIETARY_NON_ALGO));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PROGRAM_ORDER_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROGRAM_ORDER_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PROGRAM_ORDER_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_INDIVIDUAL_INVESTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_INDIVIDUAL_INVESTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_INDIVIDUAL_INVESTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_INDIVIDUAL_INVESTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PROPRIETARY_ALGO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROPRIETARY_ALGO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PROPRIETARY_ALGO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROPRIETARY_ALGO));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_AGENCY_ALGO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_AGENCY_ALGO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_AGENCY_ALGO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENCY_ALGO));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PROGRAM_ORDER_OTHER_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROGRAM_ORDER_OTHER_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PROGRAM_ORDER_OTHER_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_OTHER_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_AGENT_FOR_OTHER_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_AGENT_FOR_OTHER_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_AGENT_FOR_OTHER_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENT_FOR_OTHER_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_AGENCY_INDEX_ARB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_AGENCY_INDEX_ARB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_AGENCY_INDEX_ARB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENCY_INDEX_ARB));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_AGENCY_NON_ALGO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_AGENCY_NON_ALGO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_AGENCY_NON_ALGO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENCY_NON_ALGO));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_A_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_A_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_A_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_A_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_W_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_W_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_W_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_W_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_I_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_I_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_I_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_I_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_MEMBER_AFFLIATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_MEMBER_AFFLIATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_MEMBER_AFFLIATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_MEMBER_AFFLIATED));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PROPRIETARY_TRANSACTION_AFFILIATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROPRIETARY_TRANSACTION_AFFILIATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PROPRIETARY_TRANSACTION_AFFILIATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROPRIETARY_TRANSACTION_AFFILIATED));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_TRANSACTION_NON_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_TRANSACTION_NON_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_TRANSACTION_NON_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_TRANSACTION_NON_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SPECIALIST_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SPECIALIST_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SPECIALIST_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SPECIALIST_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_TRANSACTION_UNAFFILIATED_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_TRANSACTION_UNAFFILIATED_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_TRANSACTION_UNAFFILIATED_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_TRANSACTION_UNAFFILIATED_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_MEMBER_NOT_AFFLIATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_MEMBER_NOT_AFFLIATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_MEMBER_NOT_AFFLIATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_MEMBER_NOT_AFFLIATED));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_NON_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_NON_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_NON_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_NON_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_BUY));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELL));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_BUY_MINUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_BUY_MINUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_BUY_MINUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_BUY_MINUS));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_SELL_PLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELL_PLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_SELL_PLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELL_PLUS));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_SELL_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELL_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_SELL_SHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELL_SHORT));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_SELL_SHORT_EXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELL_SHORT_EXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_SELL_SHORT_EXEMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELL_SHORT_EXEMPT));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_UNDISCLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_UNDISCLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_UNDISCLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_UNDISCLOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_CROSS_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_CROSS_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_CROSS_SHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_CROSS_SHORT));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_AS_DEFINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_AS_DEFINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_AS_DEFINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_AS_DEFINED));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_OPPOSITE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_OPPOSITE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_OPPOSITE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_OPPOSITE));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_CROSS_SHORT_EXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_CROSS_SHORT_EXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_CROSS_SHORT_EXEMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_CROSS_SHORT_EXEMPT));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_SUBSCRIBE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SUBSCRIBE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_SUBSCRIBE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SUBSCRIBE));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_REDEEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_REDEEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_REDEEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_REDEEM));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_LEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_LEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_LEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_LEND));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_BORROW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_BORROW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_BORROW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_BORROW));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_SELL_UNDISCLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELL_UNDISCLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_SELL_UNDISCLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELL_UNDISCLOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_GOOD_TILL_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_TILL_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_GOOD_TILL_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_TILL_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_AT_THE_OPENING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_AT_THE_OPENING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_AT_THE_OPENING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_AT_THE_OPENING));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_IMMEDIATE_OR_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_IMMEDIATE_OR_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_IMMEDIATE_OR_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_IMMEDIATE_OR_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_FILL_OR_KILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_FILL_OR_KILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_FILL_OR_KILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_FILL_OR_KILL));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_GOOD_TILL_CROSSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_TILL_CROSSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_GOOD_TILL_CROSSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_TILL_CROSSING));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_GOOD_TILL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_TILL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_GOOD_TILL_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_TILL_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_AT_THE_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_AT_THE_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_AT_THE_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_AT_THE_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_GOOD_THROUGH_CROSSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_THROUGH_CROSSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_GOOD_THROUGH_CROSSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_THROUGH_CROSSING));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_AT_CROSSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_AT_CROSSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_AT_CROSSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_AT_CROSSING));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_GOOD_FOR_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_FOR_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_GOOD_FOR_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_FOR_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_GOOD_FOR_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_FOR_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_GOOD_FOR_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_FOR_AUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_GOOD_FOR_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_FOR_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_GOOD_FOR_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_FOR_MONTH));
  return pyobj;
}


SWIGINTERN int Swig_var_Urgency_NORMAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Urgency_NORMAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Urgency_NORMAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Urgency_NORMAL));
  return pyobj;
}


SWIGINTERN int Swig_var_Urgency_FLASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Urgency_FLASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Urgency_FLASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Urgency_FLASH));
  return pyobj;
}


SWIGINTERN int Swig_var_Urgency_BACKGROUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Urgency_BACKGROUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Urgency_BACKGROUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Urgency_BACKGROUND));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_REGULAR));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_CASH));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_NEXT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_NEXT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_NEXT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_NEXT_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_T_PLUS2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T_PLUS2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_T_PLUS2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T_PLUS2));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_T_PLUS3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T_PLUS3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_T_PLUS3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T_PLUS3));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_T_PLUS4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T_PLUS4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_T_PLUS4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T_PLUS4));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_FUTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_FUTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_FUTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_FUTURE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_WHEN_AND_IF_ISSUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_WHEN_AND_IF_ISSUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_WHEN_AND_IF_ISSUED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_WHEN_AND_IF_ISSUED));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_SELLERS_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_SELLERS_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_SELLERS_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_SELLERS_OPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_T_PLUS5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T_PLUS5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_T_PLUS5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T_PLUS5));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_T1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_T1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T1));
  return pyobj;
}


SWIGINTERN int Swig_var_SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST);
  return pyobj;
}


SWIGINTERN int Swig_var_SymbolSfx_WHEN_ISSUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SymbolSfx_WHEN_ISSUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SymbolSfx_WHEN_ISSUED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SymbolSfx_WHEN_ISSUED);
  return pyobj;
}


SWIGINTERN int Swig_var_AllocTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocTransType_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocTransType_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocTransType_CALCULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_CALCULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocTransType_CALCULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CALCULATED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocTransType_CALCULATED_WITHOUT_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_CALCULATED_WITHOUT_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocTransType_CALCULATED_WITHOUT_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CALCULATED_WITHOUT_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocTransType_REVERSAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_REVERSAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocTransType_REVERSAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_REVERSAL));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenClose_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenClose_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenClose_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenClose_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenClose_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenClose_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenClose_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenClose_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_ProcessCode_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProcessCode_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_REGULAR));
  return pyobj;
}


SWIGINTERN int Swig_var_ProcessCode_SOFT_DOLLAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_SOFT_DOLLAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProcessCode_SOFT_DOLLAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_SOFT_DOLLAR));
  return pyobj;
}


SWIGINTERN int Swig_var_ProcessCode_STEP_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_STEP_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProcessCode_STEP_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEP_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_ProcessCode_STEP_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_STEP_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProcessCode_STEP_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEP_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_ProcessCode_SOFT_DOLLAR_STEP_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_SOFT_DOLLAR_STEP_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProcessCode_SOFT_DOLLAR_STEP_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_SOFT_DOLLAR_STEP_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_ProcessCode_SOFT_DOLLAR_STEP_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_SOFT_DOLLAR_STEP_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProcessCode_SOFT_DOLLAR_STEP_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_SOFT_DOLLAR_STEP_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_ProcessCode_PLAN_SPONSOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_PLAN_SPONSOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProcessCode_PLAN_SPONSOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_PLAN_SPONSOR));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_BLOCK_LEVEL_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_BLOCK_LEVEL_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_BLOCK_LEVEL_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_BLOCK_LEVEL_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_ACCOUNT_LEVEL_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_ACCOUNT_LEVEL_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_ACCOUNT_LEVEL_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ACCOUNT_LEVEL_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_INCOMPLETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_INCOMPLETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_INCOMPLETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_INCOMPLETE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_REJECTED_BY_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_REJECTED_BY_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_REJECTED_BY_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REJECTED_BY_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_ALLOCATION_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_ALLOCATION_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_ALLOCATION_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ALLOCATION_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_REVERSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_REVERSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_REVERSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REVERSED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_CANCELLED_BY_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_CANCELLED_BY_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_CANCELLED_BY_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_CANCELLED_BY_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_CLAIMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_CLAIMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_CLAIMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_CLAIMED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_REFUSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_REFUSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_REFUSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REFUSED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_PENDING_GIVE_UP_APPROVAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_PENDING_GIVE_UP_APPROVAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_PENDING_GIVE_UP_APPROVAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_PENDING_GIVE_UP_APPROVAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_CANCELLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_CANCELLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_CANCELLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_CANCELLED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_PENDING_TAKE_UP_APPROVAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_PENDING_TAKE_UP_APPROVAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_PENDING_TAKE_UP_APPROVAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_PENDING_TAKE_UP_APPROVAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_REVERSAL_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_REVERSAL_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_REVERSAL_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REVERSAL_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_UNKNOWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_UNKNOWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_AVERAGEG_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_AVERAGEG_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_AVERAGEG_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_AVERAGEG_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_COMMISSION_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_COMMISSION_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_COMMISSION_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_COMMISSION_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_UNKNOWN_ORDER_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_ORDER_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_UNKNOWN_ORDER_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_ORDER_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_UNKNOWN_LIST_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_LIST_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_UNKNOWN_LIST_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_LIST_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_OTHER_SEE_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_OTHER_SEE_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_OTHER_SEE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_OTHER_SEE_TEXT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_ALLOCATED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_ALLOCATED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_ALLOCATED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_ALLOCATED_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_CALCULATION_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_CALCULATION_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_CALCULATION_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_CALCULATION_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_UNKNOWN_OR_STALE_EXEC_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_OR_STALE_EXEC_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_UNKNOWN_OR_STALE_EXEC_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_OR_STALE_EXEC_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_MISMATCHED_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_MISMATCHED_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_MISMATCHED_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_MISMATCHED_DATA));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_UNKNOWN_CL_ORD_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_CL_ORD_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_UNKNOWN_CL_ORD_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_CL_ORD_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_WAREHOUSE_REQUEST_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_WAREHOUSE_REQUEST_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_WAREHOUSE_REQUEST_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_WAREHOUSE_REQUEST_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_AVERAGE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_AVERAGE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_AVERAGE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_AVERAGE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_DUPLICATE_OR_MISSING_INDIVIDUAL_ALLOC_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_DUPLICATE_OR_MISSING_INDIVIDUAL_ALLOC_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_DUPLICATE_OR_MISSING_INDIVIDUAL_ALLOC_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_DUPLICATE_OR_MISSING_INDIVIDUAL_ALLOC_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_TRADE_NOT_RECOGNIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_TRADE_NOT_RECOGNIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_TRADE_NOT_RECOGNIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_TRADE_NOT_RECOGNIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_DUPLICATE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_DUPLICATE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_DUPLICATE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_DUPLICATE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_OR_MISSING_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_OR_MISSING_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_OR_MISSING_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_OR_MISSING_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SETTL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_OR_MISSING_SETTL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SETTL_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_OR_MISSING_SETTL_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_OR_MISSING_FUND_ID_OR_FUND_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_OR_MISSING_FUND_ID_OR_FUND_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_OR_MISSING_FUND_ID_OR_FUND_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_OR_MISSING_FUND_ID_OR_FUND_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SETTL_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_OR_MISSING_SETTL_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SETTL_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_OR_MISSING_SETTL_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_OR_MISSING_FEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_OR_MISSING_FEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_OR_MISSING_FEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_OR_MISSING_FEES));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_OR_MISSING_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_OR_MISSING_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_OR_MISSING_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_OR_MISSING_TAX));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_UNKNOWN_OR_MISSING_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_OR_MISSING_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_UNKNOWN_OR_MISSING_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_OR_MISSING_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_OR_MISSING_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_OR_MISSING_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_OR_MISSING_NET_MONEY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_OR_MISSING_NET_MONEY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_OR_MISSING_NET_MONEY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_OR_MISSING_NET_MONEY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_OR_MISSING_TRADE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_OR_MISSING_TRADE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_OR_MISSING_TRADE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_OR_MISSING_TRADE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SETTL_CCY_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_OR_MISSING_SETTL_CCY_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SETTL_CCY_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_OR_MISSING_SETTL_CCY_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_OR_MISSING_PROCESS_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_OR_MISSING_PROCESS_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_OR_MISSING_PROCESS_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_OR_MISSING_PROCESS_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_EmailType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EmailType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EmailType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::EmailType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_EmailType_REPLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EmailType_REPLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EmailType_REPLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::EmailType_REPLY));
  return pyobj;
}


SWIGINTERN int Swig_var_EmailType_ADMIN_REPLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EmailType_ADMIN_REPLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EmailType_ADMIN_REPLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::EmailType_ADMIN_REPLY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestination_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestination_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestination_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestination_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestination_POSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestination_POSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestination_POSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestination_POSIT));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_TOO_LATE_TO_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_TOO_LATE_TO_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_TOO_LATE_TO_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_TOO_LATE_TO_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_UNKNOWN_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_UNKNOWN_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_UNKNOWN_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_UNKNOWN_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_BROKER_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_BROKER_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_BROKER_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_BROKER_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_ORDER_ALREADY_IN_PENDING_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_ORDER_ALREADY_IN_PENDING_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_ORDER_ALREADY_IN_PENDING_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_ORDER_ALREADY_IN_PENDING_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_DUPLICATE_CL_ORD_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_DUPLICATE_CL_ORD_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_DUPLICATE_CL_ORD_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_DUPLICATE_CL_ORD_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_ORIG_ORD_MOD_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_ORIG_ORD_MOD_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_ORIG_ORD_MOD_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_ORIG_ORD_MOD_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_INVALID_PRICE_INCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_INVALID_PRICE_INCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_INVALID_PRICE_INCREMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_INVALID_PRICE_INCREMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_BROKER_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_BROKER_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_BROKER_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_BROKER_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_EXCHANGE_CLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_EXCHANGE_CLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_EXCHANGE_CLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_EXCHANGE_CLOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_ORDER_EXCEEDS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_ORDER_EXCEEDS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_ORDER_EXCEEDS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_ORDER_EXCEEDS_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_TOO_LATE_TO_ENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_TOO_LATE_TO_ENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_TOO_LATE_TO_ENTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_TOO_LATE_TO_ENTER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_UNKNOWN_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_UNKNOWN_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_UNKNOWN_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_DUPLICATE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_DUPLICATE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_DUPLICATE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_DUPLICATE_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_STALE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_STALE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_STALE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_STALE_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_TRADE_ALONG_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_TRADE_ALONG_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_TRADE_ALONG_REQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_TRADE_ALONG_REQUIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_INVALID_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_INVALID_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_INVALID_INVESTOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INVALID_INVESTOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_SURVEILLENCE_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_SURVEILLENCE_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_SURVEILLENCE_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_SURVEILLENCE_OPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_INCORRECT_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_INCORRECT_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_INCORRECT_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INCORRECT_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_INCORRECT_ALLOCATED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_INCORRECT_ALLOCATED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_INCORRECT_ALLOCATED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INCORRECT_ALLOCATED_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_UNKNOWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_UNKNOWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_UNKNOWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_INVALID_PRICE_INCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_INVALID_PRICE_INCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_INVALID_PRICE_INCREMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INVALID_PRICE_INCREMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_SURVEILLANCE_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_SURVEILLANCE_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_SURVEILLANCE_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_SURVEILLANCE_OPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_REFERENCE_PRICE_NOT_AVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_REFERENCE_PRICE_NOT_AVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_REFERENCE_PRICE_NOT_AVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_REFERENCE_PRICE_NOT_AVAILABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_ALGORITHM_RISK_THRESHOLD_BREACHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_ALGORITHM_RISK_THRESHOLD_BREACHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_ALGORITHM_RISK_THRESHOLD_BREACHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_ALGORITHM_RISK_THRESHOLD_BREACHED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_SHORT_SELL_NOT_PERMITTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_SHORT_SELL_NOT_PERMITTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_SHORT_SELL_NOT_PERMITTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_SHORT_SELL_NOT_PERMITTED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_SHORT_SELL_SECURITY_PRE_BORROW_RESTRICTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_SHORT_SELL_SECURITY_PRE_BORROW_RESTRICTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_SHORT_SELL_SECURITY_PRE_BORROW_RESTRICTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_SHORT_SELL_SECURITY_PRE_BORROW_RESTRICTION));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_SHORT_SELL_ACCOUNT_PRE_BORROW_RESTRICTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_SHORT_SELL_ACCOUNT_PRE_BORROW_RESTRICTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_SHORT_SELL_ACCOUNT_PRE_BORROW_RESTRICTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_SHORT_SELL_ACCOUNT_PRE_BORROW_RESTRICTION));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_INSUFFICIENT_CREDIT_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_INSUFFICIENT_CREDIT_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_INSUFFICIENT_CREDIT_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INSUFFICIENT_CREDIT_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_EXCEEDED_CLIP_SIZE_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_EXCEEDED_CLIP_SIZE_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_EXCEEDED_CLIP_SIZE_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_EXCEEDED_CLIP_SIZE_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_EXCEEDED_DV01_PV01_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_EXCEEDED_DV01_PV01_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_EXCEEDED_DV01_PV01_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_EXCEEDED_DV01_PV01_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_EXCEEDED_CS01_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_EXCEEDED_CS01_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_EXCEEDED_CS01_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_EXCEEDED_CS01_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_ALL_OR_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_ALL_OR_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_AT_THE_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AT_THE_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_AT_THE_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AT_THE_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_IN_TOUCH_WITH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_IN_TOUCH_WITH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_IN_TOUCH_WITH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_IN_TOUCH_WITH));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_MORE_BEHIND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_MORE_BEHIND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_MORE_BEHIND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_MORE_BEHIND));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_AT_THE_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AT_THE_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_AT_THE_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AT_THE_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_TAKING_A_POSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_TAKING_A_POSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_TAKING_A_POSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_TAKING_A_POSITION));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_AT_THE_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AT_THE_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_AT_THE_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AT_THE_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_PORTFOLIO_SHOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_PORTFOLIO_SHOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_PORTFOLIO_SHOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PORTFOLIO_SHOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_THROUGH_THE_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_THROUGH_THE_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_THROUGH_THE_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_THROUGH_THE_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_VERSUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_VERSUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_VERSUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_VERSUS));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_INDICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_INDICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_INDICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_INDICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_CROSSING_OPPORTUNITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_CROSSING_OPPORTUNITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_CROSSING_OPPORTUNITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_CROSSING_OPPORTUNITY));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_AT_THE_MIDPOINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AT_THE_MIDPOINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_AT_THE_MIDPOINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AT_THE_MIDPOINT));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_PRE_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_PRE_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_PRE_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PRE_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_READY_TO_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_READY_TO_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_READY_TO_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_READY_TO_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_VWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_MARKET_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_MARKET_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_MARKET_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_MARKET_ON_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_AXE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AXE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_AXE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AXE));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_AXE_ON_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AXE_ON_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_AXE_ON_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AXE_ON_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_AXE_ON_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AXE_ON_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_AXE_ON_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AXE_ON_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_CLIENT_NATURAL_WORKING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_CLIENT_NATURAL_WORKING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_CLIENT_NATURAL_WORKING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_CLIENT_NATURAL_WORKING));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_POSITION_WANTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_POSITION_WANTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_POSITION_WANTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_POSITION_WANTED));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_MARKET_MAKING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_MARKET_MAKING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_MARKET_MAKING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_MARKET_MAKING));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_CLIENT_NATURAL_BLOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_CLIENT_NATURAL_BLOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_CLIENT_NATURAL_BLOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_CLIENT_NATURAL_BLOCK));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_UNWIND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_UNWIND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_UNWIND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_UNWIND));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_QUANTITY_NEGOTIABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_QUANTITY_NEGOTIABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_QUANTITY_NEGOTIABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_QUANTITY_NEGOTIABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_ALLOW_LATE_BIDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_ALLOW_LATE_BIDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_ALLOW_LATE_BIDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_ALLOW_LATE_BIDS));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_IMMEDIATE_OR_COUNTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_IMMEDIATE_OR_COUNTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_IMMEDIATE_OR_COUNTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_IMMEDIATE_OR_COUNTER));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_AUTO_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AUTO_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_AUTO_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AUTO_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_AUTOMATIC_SPOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AUTOMATIC_SPOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_AUTOMATIC_SPOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AUTOMATIC_SPOT));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_PLATFORM_CALCULATED_SPOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_PLATFORM_CALCULATED_SPOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_PLATFORM_CALCULATED_SPOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PLATFORM_CALCULATED_SPOT));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_OUTSIDE_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_OUTSIDE_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_OUTSIDE_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_OUTSIDE_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_DEFERRED_SPOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_DEFERRED_SPOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_DEFERRED_SPOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_DEFERRED_SPOT));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_NEGOTIATED_SPOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_NEGOTIATED_SPOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_NEGOTIATED_SPOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_NEGOTIATED_SPOT));
  return pyobj;
}


SWIGINTERN int Swig_var_ReportToExch_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReportToExch_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReportToExch_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ReportToExch_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_ReportToExch_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReportToExch_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReportToExch_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ReportToExch_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_LocateReqd_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LocateReqd_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LocateReqd_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LocateReqd_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_LocateReqd_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LocateReqd_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LocateReqd_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LocateReqd_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_ForexReq_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ForexReq_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ForexReq_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ForexReq_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_ForexReq_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ForexReq_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ForexReq_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ForexReq_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlType_FULL_REMAINING_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlType_FULL_REMAINING_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlType_FULL_REMAINING_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CxlType_FULL_REMAINING_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlType_PARTIAL_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlType_PARTIAL_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlType_PARTIAL_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CxlType_PARTIAL_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_WRONG_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_WRONG_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_WRONG_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_WRONG_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_QUANTITY_EXCEEDS_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_QUANTITY_EXCEEDS_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_QUANTITY_EXCEEDS_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_QUANTITY_EXCEEDS_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_NO_MATCHING_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_NO_MATCHING_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_NO_MATCHING_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_NO_MATCHING_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_PRICE_EXCEEDS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_PRICE_EXCEEDS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_PRICE_EXCEEDS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_PRICE_EXCEEDS_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_CALCULATION_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_CALCULATION_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_CALCULATION_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_CALCULATION_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_NO_MATCHING_EXECUTION_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_NO_MATCHING_EXECUTION_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_NO_MATCHING_EXECUTION_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_NO_MATCHING_EXECUTION_REPORT));
  return pyobj;
}


SWIGINTERN int Swig_var_IOINaturalFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOINaturalFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOINaturalFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOINaturalFlag_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_IOINaturalFlag_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOINaturalFlag_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOINaturalFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOINaturalFlag_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_REGULATORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_REGULATORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_REGULATORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_REGULATORY);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_TAX);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_LOCAL_COMMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_LOCAL_COMMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_LOCAL_COMMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_LOCAL_COMMISSION);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_EXCHANGE_FEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_EXCHANGE_FEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_EXCHANGE_FEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_EXCHANGE_FEES);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_STAMP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_STAMP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_STAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_STAMP);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_LEVY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_LEVY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_LEVY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_LEVY);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_OTHER);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_MARKUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_MARKUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_MARKUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_MARKUP);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_CONSUMPTION_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_CONSUMPTION_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_CONSUMPTION_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_CONSUMPTION_TAX);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_PER_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_PER_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_PER_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_PER_TRANSACTION);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_CONVERSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_CONVERSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_CONVERSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_CONVERSION);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_AGENT);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_TRANSFER_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_TRANSFER_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_TRANSFER_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_TRANSFER_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_SECURITY_LENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_SECURITY_LENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_SECURITY_LENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_SECURITY_LENDING);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_TRADE_REPORTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_TRADE_REPORTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_TRADE_REPORTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_TRADE_REPORTING);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_TAX_ON_PRINCIPAL_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_TAX_ON_PRINCIPAL_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_TAX_ON_PRINCIPAL_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_TAX_ON_PRINCIPAL_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_TAX_ON_ACCRUED_INTEREST_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_TAX_ON_ACCRUED_INTEREST_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_TAX_ON_ACCRUED_INTEREST_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_TAX_ON_ACCRUED_INTEREST_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_NEW_ISSUANCE_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_NEW_ISSUANCE_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_NEW_ISSUANCE_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_NEW_ISSUANCE_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_SERVICE_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_SERVICE_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_SERVICE_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_SERVICE_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_ODD_LOT_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_ODD_LOT_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_ODD_LOT_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_ODD_LOT_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_AUCTION_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_AUCTION_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_AUCTION_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_AUCTION_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_VALUE_ADDED_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_VALUE_ADDED_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_VALUE_ADDED_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_VALUE_ADDED_TAX);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_SALES_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_SALES_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_SALES_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_SALES_TAX);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_EXECUTION_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_EXECUTION_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_EXECUTION_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_EXECUTION_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_ORDER_ENTRY_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_ORDER_ENTRY_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_ORDER_ENTRY_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_ORDER_ENTRY_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_ORDER_MODIFICATION_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_ORDER_MODIFICATION_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_ORDER_MODIFICATION_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_ORDER_MODIFICATION_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_ORDERS_CANCELLATION_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_ORDERS_CANCELLATION_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_ORDERS_CANCELLATION_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_ORDERS_CANCELLATION_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_MARKET_DATA_ACCESS_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_MARKET_DATA_ACCESS_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_MARKET_DATA_ACCESS_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_MARKET_DATA_ACCESS_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_MARKET_DATA_TERMINAL_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_MARKET_DATA_TERMINAL_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_MARKET_DATA_TERMINAL_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_MARKET_DATA_TERMINAL_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_MARKET_DATA_VOLUME_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_MARKET_DATA_VOLUME_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_MARKET_DATA_VOLUME_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_MARKET_DATA_VOLUME_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_CLEARING_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_CLEARING_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_CLEARING_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_CLEARING_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_SETTLEMENT_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_SETTLEMENT_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_SETTLEMENT_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_SETTLEMENT_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_REBATES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_REBATES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_REBATES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_REBATES);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_DISCOUNTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_DISCOUNTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_DISCOUNTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_DISCOUNTS);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_PAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_PAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_PAYMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_PAYMENTS);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_NON_MONETARY_PAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_NON_MONETARY_PAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_NON_MONETARY_PAYMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_NON_MONETARY_PAYMENTS);
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_PARTIAL_FILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PARTIAL_FILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_PARTIAL_FILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PARTIAL_FILL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_FILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_FILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_FILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_FILL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_DONE_FOR_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_DONE_FOR_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_DONE_FOR_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_DONE_FOR_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_CANCELED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_CANCELED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_CANCELED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_CANCELED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_REPLACED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_REPLACED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_REPLACED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_REPLACED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_PENDING_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PENDING_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_PENDING_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_STOPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_STOPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_STOPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_STOPPED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_SUSPENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_SUSPENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_SUSPENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_SUSPENDED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_PENDING_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PENDING_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_PENDING_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_CALCULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_CALCULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_CALCULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_CALCULATED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_RESTATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_RESTATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_RESTATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_RESTATED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_PENDING_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PENDING_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_PENDING_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_TRADE_CORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADE_CORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_TRADE_CORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_CORRECT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_TRADE_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADE_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_TRADE_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_ORDER_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_ORDER_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_ORDER_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_ORDER_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_TRADE_IN_A_CLEARING_HOLD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADE_IN_A_CLEARING_HOLD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_TRADE_IN_A_CLEARING_HOLD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_IN_A_CLEARING_HOLD));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_LOCKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_LOCKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_LOCKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_LOCKED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_RELEASED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_RELEASED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_RELEASED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_RELEASED));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlCurrFxRateCalc_DIVIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlCurrFxRateCalc_DIVIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlCurrFxRateCalc_DIVIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlCurrFxRateCalc_DIVIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlCurrFxRateCalc_MULTIPLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlCurrFxRateCalc_MULTIPLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlCurrFxRateCalc_MULTIPLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlCurrFxRateCalc_MULTIPLY));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstMode_DEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_DEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstMode_DEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_DEFAULT));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstMode_REQUEST_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_REQUEST_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstMode_REQUEST_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_REQUEST_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstTransType_RESTATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstTransType_RESTATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstTransType_RESTATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_RESTATE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstSource_BROKER_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstSource_BROKER_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstSource_BROKER_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_BROKER_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstSource_INSTITUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstSource_INSTITUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstSource_INSTITUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_INSTITUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstSource_INVESTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstSource_INVESTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstSource_INVESTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_INVESTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlLocation_CEDEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_CEDEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlLocation_CEDEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_CEDEL);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlLocation_DEPOSITORY_TRUST_COMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_DEPOSITORY_TRUST_COMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlLocation_DEPOSITORY_TRUST_COMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_DEPOSITORY_TRUST_COMPANY);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlLocation_EURO_CLEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_EURO_CLEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlLocation_EURO_CLEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_EURO_CLEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlLocation_FEDERAL_BOOK_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_FEDERAL_BOOK_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlLocation_FEDERAL_BOOK_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_FEDERAL_BOOK_ENTRY);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_LOCAL_MARKET_SETTLE_LOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_LOCAL_MARKET_SETTLE_LOCATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlLocation_PHYSICAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_PHYSICAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlLocation_PHYSICAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_PHYSICAL);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlLocation_PARTICIPANT_TRUST_COMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_PARTICIPANT_TRUST_COMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlLocation_PARTICIPANT_TRUST_COMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_PARTICIPANT_TRUST_COMPANY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BANKERS_ACCEPTANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BANKERS_ACCEPTANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BANKERS_ACCEPTANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BANKERS_ACCEPTANCE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CERTIFICATE_OF_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CERTIFICATE_OF_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CERTIFICATE_OF_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_DEPOSIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CORPORATE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CORPORATE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CORPORATE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CORPORATE_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_COMMERCIAL_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COMMERCIAL_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_COMMERCIAL_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COMMERCIAL_PAPER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CORPORATE_PRIVATE_PLACEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CORPORATE_PRIVATE_PLACEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CORPORATE_PRIVATE_PLACEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CORPORATE_PRIVATE_PLACEMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_COMMON_STOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COMMON_STOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_COMMON_STOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COMMON_STOCK);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FEDERAL_HOUSING_AUTHORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_HOUSING_AUTHORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FEDERAL_HOUSING_AUTHORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_HOUSING_AUTHORITY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FEDERAL_HOME_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_HOME_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FEDERAL_HOME_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_HOME_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FOREIGN_EXCHANGE_CONTRACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FOREIGN_EXCHANGE_CONTRACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FOREIGN_EXCHANGE_CONTRACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FOREIGN_EXCHANGE_CONTRACT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FUTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FUTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FUTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FUTURE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TREASURIES_AGENCY_DEBENTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TREASURIES_AGENCY_DEBENTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TREASURIES_AGENCY_DEBENTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TREASURIES_AGENCY_DEBENTURE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MUTUAL_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MUTUAL_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MUTUAL_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MUTUAL_FUND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MORTGAGE_INTEREST_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_INTEREST_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MORTGAGE_INTEREST_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_INTEREST_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MORTGAGE_PRINCIPAL_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_PRINCIPAL_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MORTGAGE_PRINCIPAL_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_PRINCIPAL_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MORTGAGE_PRIVATE_PLACEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_PRIVATE_PLACEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MORTGAGE_PRIVATE_PLACEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_PRIVATE_PLACEMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MISCELLANEOUS_PASS_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MISCELLANEOUS_PASS_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MISCELLANEOUS_PASS_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MISCELLANEOUS_PASS_THROUGH);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MUNICIPAL_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MUNICIPAL_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MUNICIPAL_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MUNICIPAL_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_NO_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_NO_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_NO_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_NO_SECURITY_TYPE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OPTION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PREFERRED_STOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PREFERRED_STOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PREFERRED_STOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PREFERRED_STOCK);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REPURCHASE_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REPURCHASE_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REPURCHASE_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REPURCHASE_AGREEMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REVERSE_REPURCHASE_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVERSE_REPURCHASE_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REVERSE_REPURCHASE_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVERSE_REPURCHASE_AGREEMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TIME_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TIME_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TIME_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TIME_DEPOSIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_TREASURY_BILL_OLD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_BILL_OLD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_TREASURY_BILL_OLD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BILL_OLD);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_WARRANT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_WARRANT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_WARRANT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_WARRANT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CATS_TIGERS_AND_LIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CATS_TIGERS_AND_LIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CATS_TIGERS_AND_LIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CATS_TIGERS_AND_LIONS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_WILDCARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_WILDCARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_WILDCARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_WILDCARD);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CONVERTIBLE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CONVERTIBLE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CONVERTIBLE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CONVERTIBLE_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_IOETTE_MORTGAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_IOETTE_MORTGAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_IOETTE_MORTGAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_IOETTE_MORTGAGE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_VARIABLE_RATE_DEMAND_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_VARIABLE_RATE_DEMAND_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_VARIABLE_RATE_DEMAND_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_VARIABLE_RATE_DEMAND_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PLAZOS_FIJOS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PLAZOS_FIJOS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PLAZOS_FIJOS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PLAZOS_FIJOS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PROMISSORY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PROMISSORY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PROMISSORY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PROMISSORY_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OVERNIGHT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OVERNIGHT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OVERNIGHT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OVERNIGHT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MEDIUM_TERM_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MEDIUM_TERM_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MEDIUM_TERM_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MEDIUM_TERM_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_AMENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_AMENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_AMENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_AMENDED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BRIDGE_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BRIDGE_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BRIDGE_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BRIDGE_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_LETTER_OF_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_LETTER_OF_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_LETTER_OF_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_LETTER_OF_CREDIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SWING_LINE_FACILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SWING_LINE_FACILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SWING_LINE_FACILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SWING_LINE_FACILITY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_DEBTOR_IN_POSSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DEBTOR_IN_POSSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_DEBTOR_IN_POSSESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DEBTOR_IN_POSSESSION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_DEFAULTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DEFAULTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_DEFAULTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DEFAULTED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_WITHDRAWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_WITHDRAWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_WITHDRAWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_WITHDRAWN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_LIQUIDITY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_LIQUIDITY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_LIQUIDITY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_LIQUIDITY_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MATURED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MATURED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MATURED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MATURED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_DEPOSIT_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DEPOSIT_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_DEPOSIT_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DEPOSIT_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_RETIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_RETIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_RETIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_RETIRED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BANK_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BANK_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BANK_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BANK_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BILL_OF_EXCHANGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BILL_OF_EXCHANGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BILL_OF_EXCHANGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BILL_OF_EXCHANGES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CALL_LOANS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CALL_LOANS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CALL_LOANS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CALL_LOANS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REPLACED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REPLACED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REPLACED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REPLACED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MANDATORY_TENDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MANDATORY_TENDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MANDATORY_TENDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MANDATORY_TENDER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REVOLVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVOLVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REVOLVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVOLVER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SHORT_TERM_LOAN_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SHORT_TERM_LOAN_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SHORT_TERM_LOAN_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SHORT_TERM_LOAN_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TO_BE_ANNOUNCED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TO_BE_ANNOUNCED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TO_BE_ANNOUNCED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TO_BE_ANNOUNCED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OTHER_ANTICIPATION_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OTHER_ANTICIPATION_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OTHER_ANTICIPATION_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OTHER_ANTICIPATION_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CERTIFICATE_OF_PARTICIPATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CERTIFICATE_OF_PARTICIPATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CERTIFICATE_OF_PARTICIPATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_PARTICIPATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MORTGAGE_BACKED_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_BACKED_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MORTGAGE_BACKED_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_BACKED_SECURITIES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REVENUE_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVENUE_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REVENUE_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVENUE_BONDS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SPECIAL_ASSESSMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SPECIAL_ASSESSMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SPECIAL_ASSESSMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_ASSESSMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SPECIAL_OBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SPECIAL_OBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SPECIAL_OBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_OBLIGATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SPECIAL_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SPECIAL_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SPECIAL_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_TAX);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TAX_ANTICIPATION_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAX_ANTICIPATION_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TAX_ANTICIPATION_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAX_ANTICIPATION_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TAX_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAX_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TAX_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAX_ALLOCATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CERTIFICATE_OF_OBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CERTIFICATE_OF_OBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CERTIFICATE_OF_OBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_OBLIGATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_GENERAL_OBLIGATION_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_GENERAL_OBLIGATION_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_GENERAL_OBLIGATION_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_GENERAL_OBLIGATION_BONDS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MULTILEG_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MULTILEG_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MULTILEG_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MULTILEG_INSTRUMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAX_REVENUE_ANTICIPATION_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAX_REVENUE_ANTICIPATION_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EXTENDED_COMM_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EXTENDED_COMM_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EXTENDED_COMM_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EXTENDED_COMM_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_AGENCY_POOLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_AGENCY_POOLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_AGENCY_POOLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_AGENCY_POOLS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_ASSET_BACKED_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_ASSET_BACKED_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_ASSET_BACKED_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_ASSET_BACKED_SECURITIES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CORP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CORP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CORP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CORP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REVENUE_ANTICIPATION_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVENUE_ANTICIPATION_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REVENUE_ANTICIPATION_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVENUE_ANTICIPATION_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REVOLVER_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVOLVER_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REVOLVER_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVOLVER_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FEDERAL_AGENCY_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_AGENCY_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FEDERAL_AGENCY_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_AGENCY_COUPON);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PRIVATE_EXPORT_FUNDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PRIVATE_EXPORT_FUNDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PRIVATE_EXPORT_FUNDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PRIVATE_EXPORT_FUNDING);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_DUAL_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DUAL_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_DUAL_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DUAL_CURRENCY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_INDEXED_LINKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_INDEXED_LINKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_INDEXED_LINKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_INDEXED_LINKED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_YANKEE_CORPORATE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_YANKEE_CORPORATE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_YANKEE_CORPORATE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_YANKEE_CORPORATE_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BRADY_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BRADY_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BRADY_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BRADY_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_TREASURY_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_TREASURY_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_TREASURY_NOTE_OLD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_NOTE_OLD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_TREASURY_NOTE_OLD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_NOTE_OLD);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TERM_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TERM_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TERM_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TERM_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_STRUCTURED_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_STRUCTURED_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_STRUCTURED_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_STRUCTURED_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_SUPRANATIONAL_COUPONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_SUPRANATIONAL_COUPONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_SUPRANATIONAL_COUPONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_SUPRANATIONAL_COUPONS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_USD_SUPRANATIONAL_COUPONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_USD_SUPRANATIONAL_COUPONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_USD_SUPRANATIONAL_COUPONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_USD_SUPRANATIONAL_COUPONS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_CORPORATE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_CORPORATE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_CORPORATE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_CORPORATE_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_SOVEREIGNS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_SOVEREIGNS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_SOVEREIGNS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_SOVEREIGNS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_TREASURY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_TREASURY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_TREASURY_BILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_BILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_TREASURY_BILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BILL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REPURCHASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REPURCHASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REPURCHASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REPURCHASE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FORWARD);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BUY_SELLBACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BUY_SELLBACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BUY_SELLBACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BUY_SELLBACK);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SECURITIES_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SECURITIES_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SECURITIES_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SECURITIES_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SECURITIES_PLEDGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SECURITIES_PLEDGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SECURITIES_PLEDGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SECURITIES_PLEDGE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_CERTIFICATE_OF_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_CERTIFICATE_OF_DEPOSIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_COMMERCIAL_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_COMMERCIAL_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_COMMERCIAL_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_COMMERCIAL_PAPER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PFANDBRIEFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PFANDBRIEFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PFANDBRIEFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PFANDBRIEFE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OPTIONS_ON_FUTURES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OPTIONS_ON_FUTURES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OPTIONS_ON_FUTURES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_FUTURES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OPTIONS_ON_PHYSICAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OPTIONS_ON_PHYSICAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OPTIONS_ON_PHYSICAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_PHYSICAL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_WILDCARD_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_WILDCARD_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_WILDCARD_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_WILDCARD_ENTRY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CASH);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_CORPORATE_FLOATING_RATE_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_CORPORATE_FLOATING_RATE_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_CORPORATE_FLOATING_RATE_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_CORPORATE_FLOATING_RATE_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CREDIT_DEFAULT_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CREDIT_DEFAULT_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CREDIT_DEFAULT_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CREDIT_DEFAULT_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_INTEREST_RATE_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_INTEREST_RATE_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_INTEREST_RATE_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_INTEREST_RATE_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OPTIONS_ON_COMBO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OPTIONS_ON_COMBO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OPTIONS_ON_COMBO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_COMBO);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CANADIAN_TREASURY_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_TREASURY_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CANADIAN_TREASURY_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_TREASURY_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CANADIAN_TREASURY_BILLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_TREASURY_BILLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CANADIAN_TREASURY_BILLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_TREASURY_BILLS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CANADIAN_PROVINCIAL_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_PROVINCIAL_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CANADIAN_PROVINCIAL_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_PROVINCIAL_BONDS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TREASURY_BILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TREASURY_BILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TREASURY_BILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TREASURY_BILL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BANK_DEPOSITORY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BANK_DEPOSITORY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BANK_DEPOSITORY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BANK_DEPOSITORY_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CANADIAN_MONEY_MARKETS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_MONEY_MARKETS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CANADIAN_MONEY_MARKETS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_MONEY_MARKETS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SECURED_LIQUIDITY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SECURED_LIQUIDITY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SECURED_LIQUIDITY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SECURED_LIQUIDITY_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TERM_LIQUIDITY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TERM_LIQUIDITY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TERM_LIQUIDITY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TERM_LIQUIDITY_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CANADIAN_MORTGAGE_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_MORTGAGE_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CANADIAN_MORTGAGE_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_MORTGAGE_BONDS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TAXABLE_MUNICIPAL_CP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAXABLE_MUNICIPAL_CP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TAXABLE_MUNICIPAL_CP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAXABLE_MUNICIPAL_CP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OFFSHORE_ISSUED_CHINESE_YUAN_CORPORATE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OFFSHORE_ISSUED_CHINESE_YUAN_CORPORATE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OFFSHORE_ISSUED_CHINESE_YUAN_CORPORATE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OFFSHORE_ISSUED_CHINESE_YUAN_CORPORATE_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PREFERRED_CORPORATE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PREFERRED_CORPORATE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PREFERRED_CORPORATE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PREFERRED_CORPORATE_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_NON_DELIVERABLE_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_NON_DELIVERABLE_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_NON_DELIVERABLE_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_NON_DELIVERABLE_FORWARD);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FX_SPOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FX_SPOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FX_SPOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FX_SPOT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FX_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FX_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FX_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FX_FORWARD);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FX_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FX_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FX_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FX_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_NON_DELIVERABLE_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_NON_DELIVERABLE_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_NON_DELIVERABLE_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_NON_DELIVERABLE_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FX_BANK_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FX_BANK_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FX_BANK_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FX_BANK_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FOREIGN_CURRENCY_DISCOUNT_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FOREIGN_CURRENCY_DISCOUNT_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FOREIGN_CURRENCY_DISCOUNT_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FOREIGN_CURRENCY_DISCOUNT_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_COLLAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COLLAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_COLLAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COLLAR);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_COMMODITY_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COMMODITY_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_COMMODITY_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COMMODITY_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EXOTIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EXOTIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EXOTIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EXOTIC);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FLOOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FLOOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FLOOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FLOOR);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FRA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FRA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FRA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FRA);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_DERIVATIVE_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DERIVATIVE_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_DERIVATIVE_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DERIVATIVE_FORWARD);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TOTAL_RETURN_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TOTAL_RETURN_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TOTAL_RETURN_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TOTAL_RETURN_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_LOAN_LEASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_LOAN_LEASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_LOAN_LEASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_LOAN_LEASE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SPOT_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SPOT_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SPOT_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SPOT_FORWARD);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SWAP_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SWAP_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SWAP_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SWAP_OPTION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TRANSMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TRANSMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TRANSMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TRANSMISSION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_INDEX);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BOND_BASKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BOND_BASKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BOND_BASKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BOND_BASKET);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CONTRACT_FOR_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CONTRACT_FOR_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CONTRACT_FOR_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CONTRACT_FOR_DIFFERENCE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CORRELATION_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CORRELATION_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CORRELATION_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CORRELATION_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_DIVIEND_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DIVIEND_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_DIVIEND_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DIVIEND_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EQUITY_BASKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EQUITY_BASKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EQUITY_BASKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EQUITY_BASKET);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EQUITY_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EQUITY_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EQUITY_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EQUITY_FORWARD);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_RETURN_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_RETURN_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_RETURN_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_RETURN_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_VARIANCE_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_VARIANCE_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_VARIANCE_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_VARIANCE_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PORTFOLIO_SWAPS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PORTFOLIO_SWAPS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PORTFOLIO_SWAPS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PORTFOLIO_SWAPS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FUTURES_ON_A_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FUTURES_ON_A_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FUTURES_ON_A_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FUTURES_ON_A_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FORWARDS_ON_A_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FORWARDS_ON_A_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FORWARDS_ON_A_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FORWARDS_ON_A_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FORWARD_FREIGHT_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FORWARD_FREIGHT_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FORWARD_FREIGHT_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FORWARD_FREIGHT_AGREEMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SPREAD_BETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SPREAD_BETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SPREAD_BETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SPREAD_BETTING);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EXCHANGE_TRADED_COMMODITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EXCHANGE_TRADED_COMMODITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EXCHANGE_TRADED_COMMODITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EXCHANGE_TRADED_COMMODITY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_DEPOSITORY_RECEIPTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DEPOSITORY_RECEIPTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_DEPOSITORY_RECEIPTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DEPOSITORY_RECEIPTS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_DELIVERY_VERSUS_PLEDGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DELIVERY_VERSUS_PLEDGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_DELIVERY_VERSUS_PLEDGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DELIVERY_VERSUS_PLEDGE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_COLLATERAL_BASKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COLLATERAL_BASKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_COLLATERAL_BASKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COLLATERAL_BASKET);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_STRUCTURED_FINANCE_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_STRUCTURED_FINANCE_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_STRUCTURED_FINANCE_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_STRUCTURED_FINANCE_PRODUCT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MARGIN_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MARGIN_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MARGIN_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MARGIN_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OFFSHORE_ISSUED_CHINESE_YUAN_SOVEREIGN_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OFFSHORE_ISSUED_CHINESE_YUAN_SOVEREIGN_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OFFSHORE_ISSUED_CHINESE_YUAN_SOVEREIGN_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OFFSHORE_ISSUED_CHINESE_YUAN_SOVEREIGN_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SOVEREIGN_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SOVEREIGN_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SOVEREIGN_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SOVEREIGN_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_TREASURY_FLOATING_RATE_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_FLOATING_RATE_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_TREASURY_FLOATING_RATE_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_FLOATING_RATE_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BANK_ACCEPTED_BILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BANK_ACCEPTED_BILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BANK_ACCEPTED_BILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BANK_ACCEPTED_BILL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SHORT_TERM_BANK_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SHORT_TERM_BANK_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SHORT_TERM_BANK_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SHORT_TERM_BANK_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CALLABLE_COMMERCIAL_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CALLABLE_COMMERCIAL_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CALLABLE_COMMERCIAL_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CALLABLE_COMMERCIAL_PAPER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_COMMERCIAL_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COMMERCIAL_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_COMMERCIAL_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COMMERCIAL_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_INTEREST_BEARING_COMMERCIAL_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_INTEREST_BEARING_COMMERCIAL_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_INTEREST_BEARING_COMMERCIAL_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_INTEREST_BEARING_COMMERCIAL_PAPER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_MEDIUM_TERM_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_MEDIUM_TERM_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_MEDIUM_TERM_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_MEDIUM_TERM_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_NEGOTIABLE_COMMERCIAL_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_NEGOTIABLE_COMMERCIAL_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_NEGOTIABLE_COMMERCIAL_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_NEGOTIABLE_COMMERCIAL_PAPER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_STRUCTURED_LIQUIDITY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_STRUCTURED_LIQUIDITY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_STRUCTURED_LIQUIDITY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_STRUCTURED_LIQUIDITY_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_TIME_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_TIME_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_TIME_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_TIME_DEPOSIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_JUMBO_CERTIFICATE_OF_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_JUMBO_CERTIFICATE_OF_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_JUMBO_CERTIFICATE_OF_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_JUMBO_CERTIFICATE_OF_DEPOSIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MONEY_MARKET_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MONEY_MARKET_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MONEY_MARKET_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MONEY_MARKET_FUND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MASTER_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MASTER_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MASTER_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MASTER_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_NEGOTIABLE_CERTIFICATE_OF_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_NEGOTIABLE_CERTIFICATE_OF_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_NEGOTIABLE_CERTIFICATE_OF_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_NEGOTIABLE_CERTIFICATE_OF_DEPOSIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_NEGOTIABLE_COMMERCIAL_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_NEGOTIABLE_COMMERCIAL_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_NEGOTIABLE_COMMERCIAL_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_NEGOTIABLE_COMMERCIAL_PAPER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_RETAIL_CERTIFICATE_OF_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_RETAIL_CERTIFICATE_OF_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_RETAIL_CERTIFICATE_OF_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_RETAIL_CERTIFICATE_OF_DEPOSIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TERM_DEPOSIT_RECEIPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TERM_DEPOSIT_RECEIPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TERM_DEPOSIT_RECEIPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TERM_DEPOSIT_RECEIPT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PFANDBRIEF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PFANDBRIEF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PFANDBRIEF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PFANDBRIEF);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MUNICIPAL_INTEREST_BEARING_COMMERCIAL_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MUNICIPAL_INTEREST_BEARING_COMMERCIAL_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MUNICIPAL_INTEREST_BEARING_COMMERCIAL_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MUNICIPAL_INTEREST_BEARING_COMMERCIAL_PAPER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TAXABLE_MUNICIPAL_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAXABLE_MUNICIPAL_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TAXABLE_MUNICIPAL_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAXABLE_MUNICIPAL_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_VARIABLE_RATE_DEMAND_OBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_VARIABLE_RATE_DEMAND_OBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_VARIABLE_RATE_DEMAND_OBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_VARIABLE_RATE_DEMAND_OBLIGATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OTHER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EXCHANGE_TRADED_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EXCHANGE_TRADED_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EXCHANGE_TRADED_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EXCHANGE_TRADED_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SECURITIZED_DERIVATIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SECURITIZED_DERIVATIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SECURITIZED_DERIVATIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SECURITIZED_DERIVATIVE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EXCHANGE_TRADED_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EXCHANGE_TRADED_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EXCHANGE_TRADED_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EXCHANGE_TRADED_FUND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_DIGITAL_ASSET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DIGITAL_ASSET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_DIGITAL_ASSET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DIGITAL_ASSET);
  return pyobj;
}


SWIGINTERN int Swig_var_StandInstDbType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StandInstDbType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_StandInstDbType_DTCSID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_DTCSID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StandInstDbType_DTCSID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_DTCSID));
  return pyobj;
}


SWIGINTERN int Swig_var_StandInstDbType_THOMSON_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_THOMSON_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StandInstDbType_THOMSON_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_THOMSON_ALERT));
  return pyobj;
}


SWIGINTERN int Swig_var_StandInstDbType_A_GLOBAL_CUSTODIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_A_GLOBAL_CUSTODIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StandInstDbType_A_GLOBAL_CUSTODIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_A_GLOBAL_CUSTODIAN));
  return pyobj;
}


SWIGINTERN int Swig_var_StandInstDbType_ACCOUNT_NET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_ACCOUNT_NET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StandInstDbType_ACCOUNT_NET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_ACCOUNT_NET));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlDeliveryType_FREE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_FREE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlDeliveryType_FREE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_FREE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlDeliveryType_VERSUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_VERSUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlDeliveryType_VERSUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_VERSUS));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlDeliveryType_TRI_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_TRI_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlDeliveryType_TRI_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_TRI_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlDeliveryType_HOLD_IN_CUSTODY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_HOLD_IN_CUSTODY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlDeliveryType_HOLD_IN_CUSTODY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_HOLD_IN_CUSTODY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocLinkType_FX_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocLinkType_FX_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocLinkType_FX_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_FX_NETTING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocLinkType_FX_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocLinkType_FX_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocLinkType_FX_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_FX_SWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_PutOrCall_PUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PutOrCall_PUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PutOrCall_PUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PutOrCall_PUT));
  return pyobj;
}


SWIGINTERN int Swig_var_PutOrCall_CALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PutOrCall_CALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PutOrCall_CALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PutOrCall_CALL));
  return pyobj;
}


SWIGINTERN int Swig_var_PutOrCall_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PutOrCall_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PutOrCall_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PutOrCall_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_PutOrCall_CHOOSER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PutOrCall_CHOOSER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PutOrCall_CHOOSER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PutOrCall_CHOOSER));
  return pyobj;
}


SWIGINTERN int Swig_var_CoveredOrUncovered_COVERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CoveredOrUncovered_COVERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CoveredOrUncovered_COVERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CoveredOrUncovered_COVERED));
  return pyobj;
}


SWIGINTERN int Swig_var_CoveredOrUncovered_UNCOVERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CoveredOrUncovered_UNCOVERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CoveredOrUncovered_UNCOVERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CoveredOrUncovered_UNCOVERED));
  return pyobj;
}


SWIGINTERN int Swig_var_CustomerOrFirm_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustomerOrFirm_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustomerOrFirm_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustomerOrFirm_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_CustomerOrFirm_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustomerOrFirm_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustomerOrFirm_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustomerOrFirm_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_NotifyBrokerOfCredit_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NotifyBrokerOfCredit_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NotifyBrokerOfCredit_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::NotifyBrokerOfCredit_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_NotifyBrokerOfCredit_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NotifyBrokerOfCredit_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NotifyBrokerOfCredit_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::NotifyBrokerOfCredit_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocHandlInst_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocHandlInst_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocHandlInst_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_MATCH));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocHandlInst_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocHandlInst_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocHandlInst_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_FORWARD));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocHandlInst_FORWARD_AND_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocHandlInst_FORWARD_AND_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocHandlInst_FORWARD_AND_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_FORWARD_AND_MATCH));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocHandlInst_AUTO_CLAIM_GIVE_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocHandlInst_AUTO_CLAIM_GIVE_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocHandlInst_AUTO_CLAIM_GIVE_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_AUTO_CLAIM_GIVE_UP));
  return pyobj;
}


SWIGINTERN int Swig_var_RoutingType_TARGET_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoutingType_TARGET_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoutingType_TARGET_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGET_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_RoutingType_TARGET_LIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoutingType_TARGET_LIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoutingType_TARGET_LIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGET_LIST));
  return pyobj;
}


SWIGINTERN int Swig_var_RoutingType_BLOCK_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoutingType_BLOCK_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoutingType_BLOCK_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCK_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_RoutingType_BLOCK_LIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoutingType_BLOCK_LIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoutingType_BLOCK_LIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCK_LIST));
  return pyobj;
}


SWIGINTERN int Swig_var_RoutingType_TARGET_PERSON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoutingType_TARGET_PERSON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoutingType_TARGET_PERSON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGET_PERSON));
  return pyobj;
}


SWIGINTERN int Swig_var_RoutingType_BLOCK_PERSON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoutingType_BLOCK_PERSON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoutingType_BLOCK_PERSON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCK_PERSON));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_CURVE));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_FIVE_YR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_FIVE_YR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_FIVE_YR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_FIVE_YR));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_OLD5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_OLD5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_OLD5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD5));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_TEN_YR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_TEN_YR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_TEN_YR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_TEN_YR));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_OLD10_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_OLD10 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_OLD10_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD10));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_THIRTY_YR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_THIRTY_YR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_THIRTY_YR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_THIRTY_YR));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_OLD30_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_OLD30 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_OLD30_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD30));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_THREE_MOLIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_THREE_MOLIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_THREE_MOLIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_THREE_MOLIBOR));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_SIX_MOLIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_SIX_MOLIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_SIX_MOLIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_SIX_MOLIBOR));
  return pyobj;
}


SWIGINTERN int Swig_var_SubscriptionRequestType_SNAPSHOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SubscriptionRequestType_SNAPSHOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SubscriptionRequestType_SNAPSHOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_SNAPSHOT));
  return pyobj;
}


SWIGINTERN int Swig_var_SubscriptionRequestType_SNAPSHOT_AND_UPDATES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SubscriptionRequestType_SNAPSHOT_AND_UPDATES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SubscriptionRequestType_SNAPSHOT_AND_UPDATES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_SNAPSHOT_AND_UPDATES));
  return pyobj;
}


SWIGINTERN int Swig_var_SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateType_FULL_REFRESH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateType_FULL_REFRESH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateType_FULL_REFRESH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDUpdateType_FULL_REFRESH));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateType_INCREMENTAL_REFRESH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateType_INCREMENTAL_REFRESH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateType_INCREMENTAL_REFRESH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDUpdateType_INCREMENTAL_REFRESH));
  return pyobj;
}


SWIGINTERN int Swig_var_AggregatedBook_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AggregatedBook_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AggregatedBook_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AggregatedBook_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_AggregatedBook_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AggregatedBook_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AggregatedBook_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AggregatedBook_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_INDEX_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_INDEX_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_INDEX_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_INDEX_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_OPENING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_OPENING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_OPENING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OPENING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CLOSING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SETTLEMENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SETTLEMENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SETTLEMENT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SETTLEMENT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_TRADING_SESSION_HIGH_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADING_SESSION_HIGH_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_TRADING_SESSION_HIGH_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADING_SESSION_HIGH_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_TRADING_SESSION_LOW_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADING_SESSION_LOW_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_TRADING_SESSION_LOW_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADING_SESSION_LOW_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_TRADING_SESSION_VWAP_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADING_SESSION_VWAP_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_TRADING_SESSION_VWAP_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADING_SESSION_VWAP_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_IMBALANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_TRADE_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADE_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_TRADE_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADE_VOLUME));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_OPEN_INTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_OPEN_INTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_OPEN_INTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OPEN_INTEREST));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_COMPOSITE_UNDERLYING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_COMPOSITE_UNDERLYING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_COMPOSITE_UNDERLYING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_COMPOSITE_UNDERLYING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SIMULATED_SELL_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SIMULATED_SELL_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SIMULATED_SELL_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SIMULATED_SELL_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SIMULATED_BUY_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SIMULATED_BUY_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SIMULATED_BUY_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SIMULATED_BUY_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_MARGIN_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_MARGIN_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_MARGIN_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_MARGIN_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_MID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_MID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_MID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_MID_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_EMPTY_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_EMPTY_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_EMPTY_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_EMPTY_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SETTLE_HIGH_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SETTLE_HIGH_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SETTLE_HIGH_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SETTLE_HIGH_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SETTLE_LOW_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SETTLE_LOW_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SETTLE_LOW_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SETTLE_LOW_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_PRIOR_SETTLE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_PRIOR_SETTLE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_PRIOR_SETTLE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_PRIOR_SETTLE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SESSION_HIGH_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SESSION_HIGH_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SESSION_HIGH_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SESSION_HIGH_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SESSION_LOW_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SESSION_LOW_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SESSION_LOW_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SESSION_LOW_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_EARLY_PRICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_EARLY_PRICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_EARLY_PRICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_EARLY_PRICES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_AUCTION_CLEARING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_AUCTION_CLEARING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_AUCTION_CLEARING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_AUCTION_CLEARING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SWAP_VALUE_FACTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SWAP_VALUE_FACTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SWAP_VALUE_FACTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SWAP_VALUE_FACTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_VWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_FIXING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_FIXING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_FIXING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_FIXING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_CASH_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_CASH_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_CASH_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CASH_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_RECOVERY_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_RECOVERY_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_RECOVERY_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_RECOVERY_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_RECOVERY_RATE_FOR_LONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_RECOVERY_RATE_FOR_LONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_RECOVERY_RATE_FOR_LONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_RECOVERY_RATE_FOR_LONG));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_RECOVERY_RATE_FOR_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_RECOVERY_RATE_FOR_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_RECOVERY_RATE_FOR_SHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_RECOVERY_RATE_FOR_SHORT));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_MARKET_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_MARKET_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_MARKET_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_MARKET_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_MARKET_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_MARKET_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_MARKET_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_MARKET_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SHORT_SALE_MIN_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SHORT_SALE_MIN_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SHORT_SALE_MIN_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SHORT_SALE_MIN_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_PREVIOUS_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_PREVIOUS_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_PREVIOUS_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_PREVIOUS_CLOSING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_THRESHOLD_LIMIT_PRICE_BANDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_THRESHOLD_LIMIT_PRICE_BANDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_THRESHOLD_LIMIT_PRICE_BANDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_THRESHOLD_LIMIT_PRICE_BANDING));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_DAILY_FINANCING_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_DAILY_FINANCING_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_DAILY_FINANCING_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_DAILY_FINANCING_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_ACCRUED_FINANCING_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_ACCRUED_FINANCING_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_ACCRUED_FINANCING_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_ACCRUED_FINANCING_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_TWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_TWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_TickDirection_PLUS_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_PLUS_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickDirection_PLUS_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TickDirection_PLUS_TICK));
  return pyobj;
}


SWIGINTERN int Swig_var_TickDirection_ZERO_PLUS_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_ZERO_PLUS_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickDirection_ZERO_PLUS_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TickDirection_ZERO_PLUS_TICK));
  return pyobj;
}


SWIGINTERN int Swig_var_TickDirection_MINUS_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_MINUS_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickDirection_MINUS_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TickDirection_MINUS_TICK));
  return pyobj;
}


SWIGINTERN int Swig_var_TickDirection_ZERO_MINUS_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_ZERO_MINUS_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickDirection_ZERO_MINUS_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TickDirection_ZERO_MINUS_TICK));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_CLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_CLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CLOSED);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_EXCHANGE_BEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_EXCHANGE_BEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_EXCHANGE_BEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_EXCHANGE_BEST);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_CONSOLIDATED_BEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CONSOLIDATED_BEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_CONSOLIDATED_BEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CONSOLIDATED_BEST);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_LOCKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_LOCKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_LOCKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_LOCKED);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_CROSSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CROSSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_CROSSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CROSSED);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_DEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_FAST_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FAST_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_FAST_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FAST_TRADING);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_NON_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NON_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_NON_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NON_FIRM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_MANUAL);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_OUTRIGHT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OUTRIGHT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_OUTRIGHT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OUTRIGHT_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_IMPLIED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_IMPLIED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_IMPLIED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_IMPLIED_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_DEPTH_ON_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DEPTH_ON_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_DEPTH_ON_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH_ON_OFFER);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_DEPTH_ON_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DEPTH_ON_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_DEPTH_ON_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH_ON_BID);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_CLOSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CLOSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_CLOSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CLOSING);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_NEWS_DISSEMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NEWS_DISSEMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_NEWS_DISSEMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NEWS_DISSEMINATION);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_TRADING_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_TRADING_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_TRADING_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_TRADING_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_ORDER_INFLUX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ORDER_INFLUX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_ORDER_INFLUX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ORDER_INFLUX);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_DUE_TO_RELATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DUE_TO_RELATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_DUE_TO_RELATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_RELATED);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_NEWS_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NEWS_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_NEWS_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NEWS_PENDING);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_ADDITIONAL_INFO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ADDITIONAL_INFO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_ADDITIONAL_INFO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ADDITIONAL_INFO);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_RESUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_RESUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_RESUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_RESUME);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_VIEW_OF_COMMON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_VIEW_OF_COMMON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_VIEW_OF_COMMON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_VIEW_OF_COMMON);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_VOLUME_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_VOLUME_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_VOLUME_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_VOLUME_ALERT);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_ORDER_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ORDER_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_ORDER_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ORDER_IMBALANCE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_EQUIPMENT_CHANGEOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_EQUIPMENT_CHANGEOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_EQUIPMENT_CHANGEOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_EQUIPMENT_CHANGEOVER);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_NO_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NO_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_NO_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NO_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_REGULAR_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_REGULAR_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_REGULAR_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_REGULAR_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_AUTOMATIC_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_AUTOMATIC_EXECUTION);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_AUTOMATIC_EXECUTION_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_AUTOMATIC_EXECUTION_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_FAST_MARKET_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FAST_MARKET_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_FAST_MARKET_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FAST_MARKET_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_INACTIVE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_INACTIVE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_INACTIVE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_INACTIVE_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_ROTATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ROTATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_ROTATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ROTATION);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_ROTATION_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ROTATION_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_ROTATION_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ROTATION_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_HALT);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_HALT_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_HALT_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_HALT_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_HALT_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_DUE_TO_NEWS_DISSEMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DUE_TO_NEWS_DISSEMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_DUE_TO_NEWS_DISSEMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_NEWS_DISSEMINATION);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_DUE_TO_NEWS_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DUE_TO_NEWS_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_DUE_TO_NEWS_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_NEWS_PENDING);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_TRADING_RESUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_TRADING_RESUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_TRADING_RESUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_TRADING_RESUME);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_OUT_OF_SEQUENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OUT_OF_SEQUENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_OUT_OF_SEQUENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OUT_OF_SEQUENCE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_BID_SPECIALIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_BID_SPECIALIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_BID_SPECIALIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_BID_SPECIALIST);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_OFFER_SPECIALIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OFFER_SPECIALIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_OFFER_SPECIALIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OFFER_SPECIALIST);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_BID_OFFER_SPECIALIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_BID_OFFER_SPECIALIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_BID_OFFER_SPECIALIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_BID_OFFER_SPECIALIST);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_END_OF_DAY_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_END_OF_DAY_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_END_OF_DAY_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_END_OF_DAY_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_FORBIDDEN_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FORBIDDEN_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_FORBIDDEN_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FORBIDDEN_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_FROZEN_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FROZEN_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_FROZEN_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FROZEN_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_PRE_OPENING_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_PRE_OPENING_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_PRE_OPENING_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_PRE_OPENING_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_OPENING_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OPENING_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_OPENING_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OPENING_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_OPEN_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OPEN_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_OPEN_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OPEN_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_SURVEILLANCE_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_SURVEILLANCE_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_SURVEILLANCE_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_SURVEILLANCE_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_SUSPENDED_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_SUSPENDED_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_SUSPENDED_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_SUSPENDED_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_RESERVED_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_RESERVED_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_RESERVED_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_RESERVED_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_NO_ACTIVE_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NO_ACTIVE_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_NO_ACTIVE_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NO_ACTIVE_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_RESTRICTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_RESTRICTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_RESTRICTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_RESTRICTED);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_REST_OF_BOOK_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_REST_OF_BOOK_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_REST_OF_BOOK_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_REST_OF_BOOK_VWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_MEDIAN_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_MEDIAN_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_MEDIAN_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_MEDIAN_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_FULL_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FULL_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_FULL_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FULL_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_FLAT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FLAT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_FLAT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FLAT_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CASH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_AVERAGE_PRICE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_AVERAGE_PRICE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_AVERAGE_PRICE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_AVERAGE_PRICE_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CASH_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CASH_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CASH_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CASH_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_NEXT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_NEXT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_NEXT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_NEXT_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OPENING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OPENING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENING);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_INTRADAY_TRADE_DETAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_INTRADAY_TRADE_DETAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_INTRADAY_TRADE_DETAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_INTRADAY_TRADE_DETAIL);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_RULE127_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_RULE127_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_RULE127_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_RULE127_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_RULE155_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_RULE155_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_RULE155_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_RULE155_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SOLD_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SOLD_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SOLD_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_NEXT_DAY_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_NEXT_DAY_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_NEXT_DAY_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_NEXT_DAY_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OPENED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OPENED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENED);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SELLER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SELLER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SELLER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SELLER);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SOLD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SOLD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SOLD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SOLD);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_STOPPED_STOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED_STOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_STOPPED_STOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_STOCK);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_IMBALANCE_MORE_BUYERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_IMBALANCE_MORE_BUYERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_IMBALANCE_MORE_BUYERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_IMBALANCE_MORE_BUYERS);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_IMBALANCE_MORE_SELLERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_IMBALANCE_MORE_SELLERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_IMBALANCE_MORE_SELLERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_IMBALANCE_MORE_SELLERS);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OPENING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OPENING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENING_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_BARGAIN_CONDITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BARGAIN_CONDITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_BARGAIN_CONDITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BARGAIN_CONDITION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CONVERTED_PRICE_INDICATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CONVERTED_PRICE_INDICATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CONVERTED_PRICE_INDICATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CONVERTED_PRICE_INDICATOR);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_EXCHANGE_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_EXCHANGE_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_EXCHANGE_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_EXCHANGE_LAST);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_FINAL_PRICE_OF_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_FINAL_PRICE_OF_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_FINAL_PRICE_OF_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_FINAL_PRICE_OF_SESSION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_EX_PIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_EX_PIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_EX_PIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_EX_PIT);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CROSSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CROSSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CROSSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CROSSED);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_TRADES_RESULTING_FROM_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_TRADES_RESULTING_FROM_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_TRADES_RESULTING_FROM_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_TRADES_RESULTING_FROM_MANUAL);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_VOLUME_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_VOLUME_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_VOLUME_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_VOLUME_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_DIRECT_PLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_DIRECT_PLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_DIRECT_PLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_DIRECT_PLUS);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_ACQUISITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_ACQUISITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_ACQUISITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_ACQUISITION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_BUNCHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BUNCHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_BUNCHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BUNCHED);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_DISTRIBUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_DISTRIBUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_DISTRIBUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_DISTRIBUTION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_BUNCHED_SALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BUNCHED_SALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_BUNCHED_SALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BUNCHED_SALE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SPLIT_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SPLIT_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SPLIT_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SPLIT_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_STOPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_STOPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_STOPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_STOPPED);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_STOPPED_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_STOPPED_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_STOPPED_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_STOPPED_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OUT_OF_SEQUENCE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OUT_OF_SEQUENCE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OUT_OF_SEQUENCE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OUT_OF_SEQUENCE_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_LAST_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_LAST_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_LAST_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_LAST_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SOLD_LAST_SALE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SOLD_LAST_SALE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SOLD_LAST_SALE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST_SALE_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_LAST);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SOLD_LAST_SALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SOLD_LAST_SALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SOLD_LAST_SALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST_SALE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_OPEN_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_OPEN_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_OPEN_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_OPEN_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OPENED_SALE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENED_SALE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OPENED_SALE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENED_SALE_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_ONLY_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_ONLY_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_ONLY_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ONLY_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_LATE_OPEN_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_LATE_OPEN_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_LATE_OPEN_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_LATE_OPEN_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_AUTO_EXECUTION_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_AUTO_EXECUTION_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_AUTO_EXECUTION_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_AUTO_EXECUTION_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_REOPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_REOPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_REOPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_REOPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_REOPEN_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_REOPEN_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_REOPEN_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_REOPEN_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_ADJUSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_ADJUSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_ADJUSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_ADJUSTED);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_ADJUSTED_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_ADJUSTED_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_ADJUSTED_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_ADJUSTED_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SPREAD);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SPREAD_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SPREAD_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SPREAD_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SPREAD_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_STRADDLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STRADDLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_STRADDLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STRADDLE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_STRADDLE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STRADDLE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_STRADDLE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STRADDLE_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_STOPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_STOPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_STOPPED_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_STOPPED_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_REGULAR_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_REGULAR_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_REGULAR_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_REGULAR_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_COMBO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_COMBO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_COMBO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_COMBO);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_COMBO_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_COMBO_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_COMBO_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_COMBO_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OFFICIAL_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OFFICIAL_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OFFICIAL_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OFFICIAL_CLOSING_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_PRIOR_REFERENCE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_PRIOR_REFERENCE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_PRIOR_REFERENCE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_PRIOR_REFERENCE_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_STOPPED_SOLD_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED_SOLD_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_STOPPED_SOLD_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_SOLD_LAST);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_STOPPED_OUT_OF_SEQUENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED_OUT_OF_SEQUENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_STOPPED_OUT_OF_SEQUENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_OUT_OF_SEQUENCE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OFFICAL_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OFFICAL_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OFFICAL_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OFFICAL_CLOSING_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CROSSED_OLD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CROSSED_OLD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CROSSED_OLD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CROSSED_OLD);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_FAST_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_FAST_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_FAST_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_FAST_MARKET);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_AUTOMATIC_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_AUTOMATIC_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_AUTOMATIC_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_AUTOMATIC_EXECUTION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_FORM_T_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_FORM_T is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_FORM_T_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_FORM_T);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_BASKET_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BASKET_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_BASKET_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BASKET_INDEX);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_BURST_BASKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BURST_BASKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_BURST_BASKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BURST_BASKET);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OUTSIDE_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OUTSIDE_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OUTSIDE_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OUTSIDE_SPREAD);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_IMPLIED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_IMPLIED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_IMPLIED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_IMPLIED_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_MARKETPLACE_ENTERED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_MARKETPLACE_ENTERED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_MARKETPLACE_ENTERED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_MARKETPLACE_ENTERED_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_MULTILEG_TO_MULTILEG_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_MULTILEG_TO_MULTILEG_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_MULTILEG_TO_MULTILEG_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_MULTILEG_TO_MULTILEG_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OFFICIAL_CLOSING_PRICE_DUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OFFICIAL_CLOSING_PRICE_DUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OFFICIAL_CLOSING_PRICE_DUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OFFICIAL_CLOSING_PRICE_DUP);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_TRADE_THROUGH_EXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_TRADE_THROUGH_EXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_TRADE_THROUGH_EXEMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_TRADE_THROUGH_EXEMPT);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_QUOTE_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_QUOTE_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_QUOTE_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_QUOTE_SPREAD);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_LAST_AUCTION_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_LAST_AUCTION_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_LAST_AUCTION_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_LAST_AUCTION_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_HIGH_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_HIGH_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_HIGH_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_HIGH_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_LOW_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_LOW_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_LOW_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_LOW_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SYSTEMATIC_INTERNALISER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SYSTEMATIC_INTERNALISER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SYSTEMATIC_INTERNALISER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SYSTEMATIC_INTERNALISER);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_AWAY_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_AWAY_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_AWAY_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_AWAY_MARKET);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_MIDPOINT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_MIDPOINT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_MIDPOINT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_MIDPOINT_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_TRADED_BEFORE_ISSUE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_TRADED_BEFORE_ISSUE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_TRADED_BEFORE_ISSUE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_TRADED_BEFORE_ISSUE_DATE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_PREVIOUS_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_PREVIOUS_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_PREVIOUS_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_PREVIOUS_CLOSING_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_NATIONAL_BEST_BID_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_NATIONAL_BEST_BID_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_NATIONAL_BEST_BID_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_NATIONAL_BEST_BID_OFFER);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_MULTI_ASSET_CLASS_MULTILEG_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_MULTI_ASSET_CLASS_MULTILEG_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_MULTI_ASSET_CLASS_MULTILEG_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_MULTI_ASSET_CLASS_MULTILEG_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SHORT_SALE_MIN_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SHORT_SALE_MIN_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SHORT_SALE_MIN_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SHORT_SALE_MIN_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_BENCHMARK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BENCHMARK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_BENCHMARK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BENCHMARK);
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateAction_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateAction_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateAction_CHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_CHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateAction_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_CHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateAction_DELETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_DELETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateAction_DELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateAction_DELETE_THRU_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_DELETE_THRU is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateAction_DELETE_THRU_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE_THRU));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateAction_DELETE_FROM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_DELETE_FROM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateAction_DELETE_FROM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE_FROM));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateAction_OVERLAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_OVERLAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateAction_OVERLAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_OVERLAY));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_DUPLICATE_MD_REQ_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_DUPLICATE_MD_REQ_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_DUPLICATE_MD_REQ_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_DUPLICATE_MD_REQ_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_INSUFFICIENT_BANDWIDTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_INSUFFICIENT_BANDWIDTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_INSUFFICIENT_BANDWIDTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_BANDWIDTH));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_INSUFFICIENT_PERMISSIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_INSUFFICIENT_PERMISSIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_INSUFFICIENT_PERMISSIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_PERMISSIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_SUBSCRIPTION_REQUEST_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_SUBSCRIPTION_REQUEST_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_SUBSCRIPTION_REQUEST_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_SUBSCRIPTION_REQUEST_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_MARKET_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_MARKET_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_MARKET_DEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MARKET_DEPTH));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_MD_UPDATE_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_MD_UPDATE_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_MD_UPDATE_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MD_UPDATE_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_AGGREGATED_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_AGGREGATED_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_AGGREGATED_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_AGGREGATED_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_MD_ENTRY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_MD_ENTRY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_MD_ENTRY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MD_ENTRY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_MD_IMPLICIT_DELETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_MD_IMPLICIT_DELETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_MD_IMPLICIT_DELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MD_IMPLICIT_DELETE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_OPEN_CLOSE_SETTLE_FLAG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_OPEN_CLOSE_SETTLE_FLAG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_OPEN_CLOSE_SETTLE_FLAG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_OPEN_CLOSE_SETTLE_FLAG));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_SCOPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_SCOPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_SCOPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_SCOPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_TRADING_SESSION_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_TRADING_SESSION_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_TRADING_SESSION_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_TRADING_SESSION_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_INSUFFICIENT_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_INSUFFICIENT_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_INSUFFICIENT_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_DeleteReason_CANCELLATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeleteReason_CANCELLATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeleteReason_CANCELLATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DeleteReason_CANCELLATION));
  return pyobj;
}


SWIGINTERN int Swig_var_DeleteReason_ERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeleteReason_ERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeleteReason_ERROR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DeleteReason_ERROR));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettleFlag_DAILY_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettleFlag_DAILY_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettleFlag_DAILY_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_DAILY_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettleFlag_SESSION_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettleFlag_SESSION_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettleFlag_SESSION_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_SESSION_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettleFlag_DELIVERY_SETTLEMENT_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettleFlag_DELIVERY_SETTLEMENT_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettleFlag_DELIVERY_SETTLEMENT_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_DELIVERY_SETTLEMENT_ENTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettleFlag_EXPECTED_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettleFlag_EXPECTED_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettleFlag_EXPECTED_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_EXPECTED_ENTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettleFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettleFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettleFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_FinancialStatus_BANKRUPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FinancialStatus_BANKRUPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FinancialStatus_BANKRUPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_BANKRUPT));
  return pyobj;
}


SWIGINTERN int Swig_var_FinancialStatus_PENDING_DELISTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FinancialStatus_PENDING_DELISTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FinancialStatus_PENDING_DELISTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_PENDING_DELISTING));
  return pyobj;
}


SWIGINTERN int Swig_var_FinancialStatus_RESTRICTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FinancialStatus_RESTRICTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FinancialStatus_RESTRICTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_RESTRICTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_EX_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EX_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_EX_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_EX_DISTRIBUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EX_DISTRIBUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_EX_DISTRIBUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_DISTRIBUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_EX_RIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EX_RIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_EX_RIGHTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_RIGHTS));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_EX_INTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EX_INTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_EX_INTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_INTEREST));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_CASH_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_CASH_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_CASH_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_CASH_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_STOCK_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_STOCK_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_STOCK_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_STOCK_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_NON_INTEGER_STOCK_SPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_NON_INTEGER_STOCK_SPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_NON_INTEGER_STOCK_SPLIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_NON_INTEGER_STOCK_SPLIT));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_REVERSE_STOCK_SPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_REVERSE_STOCK_SPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_REVERSE_STOCK_SPLIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_REVERSE_STOCK_SPLIT));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_STANDARD_INTEGER_STOCK_SPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_STANDARD_INTEGER_STOCK_SPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_STANDARD_INTEGER_STOCK_SPLIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_STANDARD_INTEGER_STOCK_SPLIT));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_POSITION_CONSOLIDATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_POSITION_CONSOLIDATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_POSITION_CONSOLIDATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_POSITION_CONSOLIDATION));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_LIQUIDATION_REORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_LIQUIDATION_REORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_LIQUIDATION_REORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_LIQUIDATION_REORGANIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_MERGER_REORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_MERGER_REORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_MERGER_REORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_MERGER_REORGANIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_RIGHTS_OFFERING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_RIGHTS_OFFERING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_RIGHTS_OFFERING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_RIGHTS_OFFERING));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_SHAREHOLDER_MEETING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SHAREHOLDER_MEETING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_SHAREHOLDER_MEETING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SHAREHOLDER_MEETING));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_SPINOFF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SPINOFF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_SPINOFF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SPINOFF));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_TENDER_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_TENDER_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_TENDER_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_TENDER_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_WARRANT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_WARRANT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_WARRANT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_WARRANT));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_SPECIAL_ACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SPECIAL_ACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_SPECIAL_ACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SPECIAL_ACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_SYMBOL_CONVERSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SYMBOL_CONVERSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_SYMBOL_CONVERSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SYMBOL_CONVERSION));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_CUSIP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_CUSIP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_CUSIP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_CUSIP));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_LEAP_ROLLOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_LEAP_ROLLOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_LEAP_ROLLOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_LEAP_ROLLOVER));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_SUCCESSION_EVENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SUCCESSION_EVENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_SUCCESSION_EVENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SUCCESSION_EVENT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAckStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAckStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAckStatus_CANCEL_FOR_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_CANCEL_FOR_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAckStatus_CANCEL_FOR_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_CANCEL_FOR_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAckStatus_CANCELED_FOR_UNDERLYING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_CANCELED_FOR_UNDERLYING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAckStatus_CANCELED_FOR_UNDERLYING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_CANCELED_FOR_UNDERLYING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAckStatus_CANCELED_ALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_CANCELED_ALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAckStatus_CANCELED_ALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_CANCELED_ALL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAckStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAckStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAckStatus_RECEIVED_NOT_YET_PROCESSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_RECEIVED_NOT_YET_PROCESSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAckStatus_RECEIVED_NOT_YET_PROCESSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_RECEIVED_NOT_YET_PROCESSED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_SECURITY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_ALL_QUOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_ALL_QUOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_ALL_QUOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_ALL_QUOTES));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTE_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTE_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTE_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTE_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_SPECIFIED_SINGLE_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_SPECIFIED_SINGLE_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_SPECIFIED_SINGLE_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_SPECIFIED_SINGLE_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_BY_TYPE_OF_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_BY_TYPE_OF_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_BY_TYPE_OF_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_BY_TYPE_OF_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_TOO_LATE_TO_ENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_TOO_LATE_TO_ENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_TOO_LATE_TO_ENTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_TOO_LATE_TO_ENTER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_UNKNOWN_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_UNKNOWN_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_UNKNOWN_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_UNKNOWN_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_DUPLICATE_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_DUPLICATE_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_DUPLICATE_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_DUPLICATE_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_INVALID_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_INVALID_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_INVALID_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVALID_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_INVALID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_INVALID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_INVALID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVALID_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_QUOTE_LOCKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_QUOTE_LOCKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_QUOTE_LOCKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_QUOTE_LOCKED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_DEPR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_DEPR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_DEPR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_DEPR));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_REFERENCE_PRICE_NOT_AVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_REFERENCE_PRICE_NOT_AVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_REFERENCE_PRICE_NOT_AVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_REFERENCE_PRICE_NOT_AVAILABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_INSUFFICIENT_CREDIT_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_INSUFFICIENT_CREDIT_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_INSUFFICIENT_CREDIT_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INSUFFICIENT_CREDIT_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_EXCEEDED_CLIP_SIZE_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_EXCEEDED_CLIP_SIZE_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_EXCEEDED_CLIP_SIZE_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_EXCEEDED_CLIP_SIZE_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_EXCEEDED_DV01_PV01_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_EXCEEDED_DV01_PV01_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_EXCEEDED_DV01_PV01_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_EXCEEDED_DV01_PV01_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_EXCEEDED_CS01_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_EXCEEDED_CS01_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_EXCEEDED_CS01_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_EXCEEDED_CS01_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteResponseLevel_NO_ACKNOWLEDGEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_NO_ACKNOWLEDGEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteResponseLevel_NO_ACKNOWLEDGEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_NO_ACKNOWLEDGEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestType_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestType_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestType_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_MANUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestType_AUTOMATIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestType_AUTOMATIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestType_AUTOMATIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_AUTOMATIC));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestType_CONFIRM_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestType_CONFIRM_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestType_CONFIRM_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_CONFIRM_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_SPECIFICATIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_SPECIFICATIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_SPECIFICATIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_SPECIFICATIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_REQUEST_LIST_SECURITY_TYPES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_REQUEST_LIST_SECURITY_TYPES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_REQUEST_LIST_SECURITY_TYPES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQUEST_LIST_SECURITY_TYPES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_REQUEST_LIST_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_REQUEST_LIST_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_REQUEST_LIST_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQUEST_LIST_SECURITIES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_SECURITY_TYPE_AND_OR_CFI_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_SECURITY_TYPE_AND_OR_CFI_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_SECURITY_TYPE_AND_OR_CFI_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_SECURITY_TYPE_AND_OR_CFI_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_TRADING_SESSION_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_TRADING_SESSION_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_TRADING_SESSION_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_TRADING_SESSION_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_ALL_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_ALL_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_ALL_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_ALL_SECURITIES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_MARKET_ID_OR_MARKET_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_MARKET_ID_OR_MARKET_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_MARKET_ID_OR_MARKET_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_MARKET_ID_OR_MARKET_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityResponseType_ACCEPT_AS_IS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_ACCEPT_AS_IS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityResponseType_ACCEPT_AS_IS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_ACCEPT_AS_IS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityResponseType_ACCEPT_WITH_REVISIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_ACCEPT_WITH_REVISIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityResponseType_ACCEPT_WITH_REVISIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_ACCEPT_WITH_REVISIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityResponseType_REJECT_SECURITY_PROPOSAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_REJECT_SECURITY_PROPOSAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityResponseType_REJECT_SECURITY_PROPOSAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_REJECT_SECURITY_PROPOSAL));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA));
  return pyobj;
}


SWIGINTERN int Swig_var_UnsolicitedIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnsolicitedIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnsolicitedIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::UnsolicitedIndicator_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_UnsolicitedIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnsolicitedIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnsolicitedIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::UnsolicitedIndicator_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_OPENING_DELAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_OPENING_DELAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_OPENING_DELAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_OPENING_DELAY));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_NO_MARKET_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NO_MARKET_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_NO_MARKET_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NO_MARKET_IMBALANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_ITS_PRE_OPENING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_ITS_PRE_OPENING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_ITS_PRE_OPENING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_ITS_PRE_OPENING));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_NEW_PRICE_INDICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NEW_PRICE_INDICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_NEW_PRICE_INDICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NEW_PRICE_INDICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_TRADE_DISSEMINATION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_TRADE_DISSEMINATION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_TRADE_DISSEMINATION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRADE_DISSEMINATION_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_READY_TO_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_READY_TO_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_READY_TO_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_READY_TO_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_TRADING_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRADING_HALT));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_UNKNOWN_OR_INVALID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_UNKNOWN_OR_INVALID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_UNKNOWN_OR_INVALID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_UNKNOWN_OR_INVALID));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_RESUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_RESUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_RESUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_RESUME));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_NO_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NO_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_NO_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NO_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_PRICE_INDICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_PRICE_INDICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_PRICE_INDICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRICE_INDICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_TRADING_RANGE_INDICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_TRADING_RANGE_INDICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_TRADING_RANGE_INDICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRADING_RANGE_INDICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_MARKET_IMBALANCE_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MARKET_IMBALANCE_BUY));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_MARKET_IMBALANCE_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MARKET_IMBALANCE_SELL));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_OPENING_ROTATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_OPENING_ROTATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_OPENING_ROTATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_OPENING_ROTATION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_PRE_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_PRE_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_PRE_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRE_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_FAST_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_FAST_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_FAST_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_FAST_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_PRE_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_PRE_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_PRE_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRE_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_POST_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_POST_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_POST_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_POST_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_NO_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NO_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_NO_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NO_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonChar_NEWS_DISSEMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_NEWS_DISSEMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonChar_NEWS_DISSEMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEWS_DISSEMINATION));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonChar_ORDER_INFLUX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_ORDER_INFLUX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonChar_ORDER_INFLUX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ORDER_INFLUX));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonChar_ORDER_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_ORDER_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonChar_ORDER_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ORDER_IMBALANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonChar_ADDITIONAL_INFORMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_ADDITIONAL_INFORMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonChar_ADDITIONAL_INFORMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ADDITIONAL_INFORMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonChar_NEWS_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_NEWS_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonChar_NEWS_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEWS_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonChar_EQUIPMENT_CHANGEOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_EQUIPMENT_CHANGEOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonChar_EQUIPMENT_CHANGEOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_EQUIPMENT_CHANGEOVER));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonChar_NEW_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_NEW_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonChar_NEW_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEW_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_InViewOfCommon_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InViewOfCommon_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InViewOfCommon_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::InViewOfCommon_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_InViewOfCommon_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InViewOfCommon_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InViewOfCommon_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::InViewOfCommon_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_DueToRelated_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DueToRelated_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DueToRelated_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DueToRelated_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_DueToRelated_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DueToRelated_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DueToRelated_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DueToRelated_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_Adjustment_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Adjustment_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Adjustment_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Adjustment_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_Adjustment_ERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Adjustment_ERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Adjustment_ERROR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Adjustment_ERROR));
  return pyobj;
}


SWIGINTERN int Swig_var_Adjustment_CORRECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Adjustment_CORRECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Adjustment_CORRECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Adjustment_CORRECTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionID_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionID_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionID_HALF_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_HALF_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionID_HALF_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_HALF_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionID_MORNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_MORNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionID_MORNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_MORNING);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionID_AFTERNOON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_AFTERNOON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionID_AFTERNOON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_AFTERNOON);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionID_EVENING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_EVENING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionID_EVENING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_EVENING);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionID_AFTER_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_AFTER_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionID_AFTER_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_AFTER_HOURS);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionID_HOLIDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_HOLIDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionID_HOLIDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_HOLIDAY);
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesMethod_ELECTRONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMethod_ELECTRONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesMethod_ELECTRONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_ELECTRONIC));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesMethod_OPEN_OUTCRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMethod_OPEN_OUTCRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesMethod_OPEN_OUTCRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_OPEN_OUTCRY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesMethod_TWO_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMethod_TWO_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesMethod_TWO_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_TWO_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesMethod_VOICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMethod_VOICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesMethod_VOICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_VOICE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesMode_TESTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMode_TESTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesMode_TESTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMode_TESTING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesMode_SIMULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMode_SIMULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesMode_SIMULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMode_SIMULATED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesMode_PRODUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMode_PRODUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesMode_PRODUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMode_PRODUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatus_HALTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_HALTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatus_HALTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_HALTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatus_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatus_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatus_CLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_CLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatus_CLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_CLOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatus_PRE_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_PRE_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatus_PRE_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_PRE_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatus_PRE_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_PRE_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatus_PRE_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_PRE_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatus_REQUEST_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_REQUEST_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatus_REQUEST_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_REQUEST_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatus_UNKNOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_UNKNOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatus_UNKNOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_UNKNOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_TOO_LATE_TO_ENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_TOO_LATE_TO_ENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_TOO_LATE_TO_ENTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_TOO_LATE_TO_ENTER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_UNKNOWN_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_UNKNOWN_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_UNKNOWN_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_UNKNOWN_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_DUPLICATE_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_DUPLICATE_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_DUPLICATE_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_DUPLICATE_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_INVALID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_INVALID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_INVALID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_INVALID_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_BidRequestTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidRequestTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidRequestTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidRequestTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_BidRequestTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidRequestTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidRequestTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidRequestTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_SolicitedFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SolicitedFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SolicitedFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SolicitedFlag_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_SolicitedFlag_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SolicitedFlag_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SolicitedFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SolicitedFlag_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_GT_CORPORATE_ACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_GT_CORPORATE_ACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_GT_CORPORATE_ACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_GT_CORPORATE_ACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_GT_RENEWAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_GT_RENEWAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_GT_RENEWAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_GT_RENEWAL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_VERBAL_CHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_VERBAL_CHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_VERBAL_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_VERBAL_CHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_REPRICING_OF_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_REPRICING_OF_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_REPRICING_OF_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_REPRICING_OF_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_BROKER_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_BROKER_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_BROKER_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_BROKER_OPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_PARTIAL_DECLINE_OF_ORDER_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_PARTIAL_DECLINE_OF_ORDER_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_PARTIAL_DECLINE_OF_ORDER_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_PARTIAL_DECLINE_OF_ORDER_QTY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_CANCEL_ON_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CANCEL_ON_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_CANCEL_ON_TRADING_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCEL_ON_TRADING_HALT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_CANCELED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CANCELED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_CANCELED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCELED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_WAREHOUSE_RECAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_WAREHOUSE_RECAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_WAREHOUSE_RECAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_WAREHOUSE_RECAP));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_PEG_REFRESH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_PEG_REFRESH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_PEG_REFRESH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_PEG_REFRESH));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_CANCEL_ON_CONNECTION_LOSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CANCEL_ON_CONNECTION_LOSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_CANCEL_ON_CONNECTION_LOSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCEL_ON_CONNECTION_LOSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_CANCEL_ON_LOGOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CANCEL_ON_LOGOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_CANCEL_ON_LOGOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCEL_ON_LOGOUT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_ASSIGN_TIME_PRIORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_ASSIGN_TIME_PRIORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_ASSIGN_TIME_PRIORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_ASSIGN_TIME_PRIORITY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_CANCELLED_FOR_TRADE_PRICE_VIOLATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CANCELLED_FOR_TRADE_PRICE_VIOLATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_CANCELLED_FOR_TRADE_PRICE_VIOLATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCELLED_FOR_TRADE_PRICE_VIOLATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_CANCELLED_FOR_CROSS_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CANCELLED_FOR_CROSS_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_CANCELLED_FOR_CROSS_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCELLED_FOR_CROSS_IMBALANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_CXLD_SMP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CXLD_SMP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_CXLD_SMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CXLD_SMP));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_CXLD_SMP_AGGRESSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CXLD_SMP_AGGRESSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_CXLD_SMP_AGGRESSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CXLD_SMP_AGGRESSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_CXLD_SMP_PASSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CXLD_SMP_PASSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_CXLD_SMP_PASSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CXLD_SMP_PASSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_CXLD_SMP_AGGRESSIVE_PASSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CXLD_SMP_AGGRESSIVE_PASSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_CXLD_SMP_AGGRESSIVE_PASSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CXLD_SMP_AGGRESSIVE_PASSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_UNKNOWN_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKNOWN_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_UNKNOWN_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNOWN_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKNOWN_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNOWN_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_APPLICATION_NOT_AVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_APPLICATION_NOT_AVAILABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_DELIVER_TO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_DELIVER_TO_FIRM_NOT_AVAILABLE_AT_THIS_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_DELIVER_TO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_DELIVER_TO_FIRM_NOT_AVAILABLE_AT_THIS_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_NOT_AUTHORIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_NOT_AUTHORIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_NOT_AUTHORIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_NOT_AUTHORIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_INVALID_PRICE_INCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_INVALID_PRICE_INCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_INVALID_PRICE_INCREMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_INVALID_PRICE_INCREMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_THROTTLE_LIMIT_EXCEEDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_THROTTLE_LIMIT_EXCEEDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_THROTTLE_LIMIT_EXCEEDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_THROTTLE_LIMIT_EXCEEDED));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_THROTTLE_LIMIT_EXCEEDED_SESSION_DISCONNECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_THROTTLE_LIMIT_EXCEEDED_SESSION_DISCONNECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_THROTTLE_LIMIT_EXCEEDED_SESSION_DISCONNECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_THROTTLE_LIMIT_EXCEEDED_SESSION_DISCONNECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_THROTTLED_MESSAGES_REJECTED_ON_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_THROTTLED_MESSAGES_REJECTED_ON_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_THROTTLED_MESSAGES_REJECTED_ON_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_THROTTLED_MESSAGES_REJECTED_ON_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_MsgDirection_RECEIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgDirection_RECEIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgDirection_RECEIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MsgDirection_RECEIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_MsgDirection_SEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgDirection_SEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgDirection_SEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MsgDirection_SEND));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_RELATED_TO_DISPLAYED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_DISPLAYED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_RELATED_TO_DISPLAYED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_DISPLAYED_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_RELATED_TO_MARKET_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_MARKET_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_RELATED_TO_MARKET_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_MARKET_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_RELATED_TO_PRIMARY_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_PRIMARY_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_RELATED_TO_PRIMARY_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_PRIMARY_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_RELATED_TO_MIDPOINT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_MIDPOINT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_RELATED_TO_MIDPOINT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_MIDPOINT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_RELATED_TO_LAST_TRADE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_LAST_TRADE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_RELATED_TO_LAST_TRADE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_LAST_TRADE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_RELATED_TO_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_RELATED_TO_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_VWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_AVERAGE_PRICE_GUARANTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_AVERAGE_PRICE_GUARANTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_AVERAGE_PRICE_GUARANTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_AVERAGE_PRICE_GUARANTEE));
  return pyobj;
}


SWIGINTERN int Swig_var_BidType_NON_DISCLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidType_NON_DISCLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidType_NON_DISCLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidType_NON_DISCLOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_BidType_DISCLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidType_DISCLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidType_DISCLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidType_DISCLOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_BidType_NO_BIDDING_PROCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidType_NO_BIDDING_PROCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidType_NO_BIDDING_PROCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidType_NO_BIDDING_PROCESS));
  return pyobj;
}


SWIGINTERN int Swig_var_BidDescriptorType_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidDescriptorType_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidDescriptorType_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_INDEX));
  return pyobj;
}


SWIGINTERN int Swig_var_BidDescriptorType_COUNTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidDescriptorType_COUNTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidDescriptorType_COUNTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_COUNTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_BidDescriptorType_SECTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidDescriptorType_SECTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidDescriptorType_SECTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_SECTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_SideValueInd_SIDE_VALUE1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideValueInd_SIDE_VALUE1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideValueInd_SIDE_VALUE1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDE_VALUE1));
  return pyobj;
}


SWIGINTERN int Swig_var_SideValueInd_SIDE_VALUE2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideValueInd_SIDE_VALUE2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideValueInd_SIDE_VALUE2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDE_VALUE2));
  return pyobj;
}


SWIGINTERN int Swig_var_LiquidityIndType_FIVE_DAY_MOVING_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_FIVE_DAY_MOVING_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LiquidityIndType_FIVE_DAY_MOVING_AVERAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_FIVE_DAY_MOVING_AVERAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_LiquidityIndType_TWENTY_DAY_MOVING_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_TWENTY_DAY_MOVING_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LiquidityIndType_TWENTY_DAY_MOVING_AVERAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_TWENTY_DAY_MOVING_AVERAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_LiquidityIndType_NORMAL_MARKET_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_NORMAL_MARKET_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LiquidityIndType_NORMAL_MARKET_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_NORMAL_MARKET_SIZE));
  return pyobj;
}


SWIGINTERN int Swig_var_LiquidityIndType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LiquidityIndType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_ExchangeForPhysical_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExchangeForPhysical_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExchangeForPhysical_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExchangeForPhysical_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_ExchangeForPhysical_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExchangeForPhysical_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExchangeForPhysical_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExchangeForPhysical_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_ProgRptReqs_BUY_SIDE_REQUESTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProgRptReqs_BUY_SIDE_REQUESTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProgRptReqs_BUY_SIDE_REQUESTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_BUY_SIDE_REQUESTS));
  return pyobj;
}


SWIGINTERN int Swig_var_ProgRptReqs_SELL_SIDE_SENDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProgRptReqs_SELL_SIDE_SENDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProgRptReqs_SELL_SIDE_SENDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_SELL_SIDE_SENDS));
  return pyobj;
}


SWIGINTERN int Swig_var_ProgRptReqs_REAL_TIME_EXECUTION_REPORTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProgRptReqs_REAL_TIME_EXECUTION_REPORTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProgRptReqs_REAL_TIME_EXECUTION_REPORTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_REAL_TIME_EXECUTION_REPORTS));
  return pyobj;
}


SWIGINTERN int Swig_var_IncTaxInd_NET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IncTaxInd_NET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IncTaxInd_NET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::IncTaxInd_NET));
  return pyobj;
}


SWIGINTERN int Swig_var_IncTaxInd_GROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IncTaxInd_GROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IncTaxInd_GROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::IncTaxInd_GROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeType_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeType_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeType_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeType_AGENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeType_VWAP_GUARANTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeType_VWAP_GUARANTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeType_VWAP_GUARANTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeType_VWAP_GUARANTEE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeType_GUARANTEED_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeType_GUARANTEED_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeType_GUARANTEED_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeType_GUARANTEED_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeType_RISK_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeType_RISK_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeType_RISK_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeType_RISK_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CLOSING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_CURRENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_CURRENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_CURRENT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CURRENT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_SQ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_SQ is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_SQ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_SQ));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAP_THROUGH_A_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_A_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAP_THROUGH_A_MORNING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_A_MORNING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_STRIKE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_STRIKE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_STRIKE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_STRIKE));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_OTHERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_OTHERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_OTHERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_OTHERS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PER_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PER_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PER_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PER_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_FIXED_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_FIXED_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_FIXED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_FIXED_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_DISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_DISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_DISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_DISCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_TED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_TED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_TED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_TED_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_TED_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_TED_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_TED_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_TED_YIELD));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PREMIUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PREMIUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PREMIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PREMIUM));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_YIELD));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_FIXED_CABINET_TRADE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_FIXED_CABINET_TRADE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_FIXED_CABINET_TRADE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_FIXED_CABINET_TRADE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_VARIABLE_CABINET_TRADE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_VARIABLE_CABINET_TRADE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_VARIABLE_CABINET_TRADE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_VARIABLE_CABINET_TRADE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_HALFS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_HALFS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_HALFS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_HALFS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_FOURTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_FOURTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_FOURTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_FOURTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_EIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_EIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_EIGHTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_EIGHTS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTEENTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_SIXTEENTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTEENTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_SIXTEENTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRICE_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRICE_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRICE_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRICE_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_HALVES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_HALVES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_HALVES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_HALVES));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_EIGHTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_EIGHTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_EIGHTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_EIGHTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTY_FOURTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_SIXTY_FOURTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTY_FOURTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_SIXTY_FOURTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_NORMAL_RATE_REPRESENTATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_NORMAL_RATE_REPRESENTATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_NORMAL_RATE_REPRESENTATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_NORMAL_RATE_REPRESENTATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_INVERSE_RATE_REPRESENTATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_INVERSE_RATE_REPRESENTATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_INVERSE_RATE_REPRESENTATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_INVERSE_RATE_REPRESENTATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_BASIS_POINTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_BASIS_POINTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_BASIS_POINTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_BASIS_POINTS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_UPFRONT_POINTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_UPFRONT_POINTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_UPFRONT_POINTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_UPFRONT_POINTS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_INTEREST_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_INTEREST_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_INTEREST_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_INTEREST_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PERCENTAGE_NOTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PERCENTAGE_NOTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PERCENTAGE_NOTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PERCENTAGE_NOTIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_GTBookingInst_ACCUMULATE_UNTIL_FILLED_OR_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GTBookingInst_ACCUMULATE_UNTIL_FILLED_OR_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GTBookingInst_ACCUMULATE_UNTIL_FILLED_OR_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMULATE_UNTIL_FILLED_OR_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE));
  return pyobj;
}


SWIGINTERN int Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE));
  return pyobj;
}


SWIGINTERN int Swig_var_ListStatusType_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListStatusType_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ALERT));
  return pyobj;
}


SWIGINTERN int Swig_var_ListStatusType_EXEC_STARTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_EXEC_STARTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListStatusType_EXEC_STARTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_EXEC_STARTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ListStatusType_TIMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_TIMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListStatusType_TIMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_TIMED));
  return pyobj;
}


SWIGINTERN int Swig_var_ListStatusType_RESPONSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_RESPONSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListStatusType_RESPONSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_RESPONSE));
  return pyobj;
}


SWIGINTERN int Swig_var_ListStatusType_ACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_ACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListStatusType_ACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ACK));
  return pyobj;
}


SWIGINTERN int Swig_var_ListStatusType_ALL_DONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_ALL_DONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListStatusType_ALL_DONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ALL_DONE));
  return pyobj;
}


SWIGINTERN int Swig_var_NetGrossInd_NET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetGrossInd_NET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetGrossInd_NET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetGrossInd_NET));
  return pyobj;
}


SWIGINTERN int Swig_var_NetGrossInd_GROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetGrossInd_GROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetGrossInd_GROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetGrossInd_GROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_CANCELLING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_CANCELLING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_CANCELLING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_CANCELLING));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_EXECUTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_EXECUTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_EXECUTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_EXECUTING));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_ALL_DONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_ALL_DONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_ALL_DONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_ALL_DONE));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_ALERT));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_RECEIVED_FOR_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_RECEIVED_FOR_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_RECEIVED_FOR_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_RECEIVED_FOR_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_IN_BIDDING_PROCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_IN_BIDDING_PROCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_IN_BIDDING_PROCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_IN_BIDDING_PROCESS));
  return pyobj;
}


SWIGINTERN int Swig_var_ListExecInstType_IMMEDIATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_IMMEDIATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListExecInstType_IMMEDIATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_IMMEDIATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ListExecInstType_WAIT_FOR_INSTRUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_WAIT_FOR_INSTRUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListExecInstType_WAIT_FOR_INSTRUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_WAIT_FOR_INSTRUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ListExecInstType_BUY_DRIVEN_CASH_WITHDRAW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_BUY_DRIVEN_CASH_WITHDRAW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListExecInstType_BUY_DRIVEN_CASH_WITHDRAW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_BUY_DRIVEN_CASH_WITHDRAW));
  return pyobj;
}


SWIGINTERN int Swig_var_ListExecInstType_BUY_DRIVEN_CASH_TOP_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_BUY_DRIVEN_CASH_TOP_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListExecInstType_BUY_DRIVEN_CASH_TOP_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_BUY_DRIVEN_CASH_TOP_UP));
  return pyobj;
}


SWIGINTERN int Swig_var_ListExecInstType_SELL_DRIVEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_SELL_DRIVEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListExecInstType_SELL_DRIVEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_SELL_DRIVEN));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejResponseTo_ORDER_CANCEL_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejResponseTo_ORDER_CANCEL_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejResponseTo_ORDER_CANCEL_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CxlRejResponseTo_ORDER_CANCEL_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejResponseTo_ORDER_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejResponseTo_ORDER_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejResponseTo_ORDER_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CxlRejResponseTo_ORDER_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_MultiLegReportingType_SINGLE_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegReportingType_SINGLE_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiLegReportingType_SINGLE_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_SINGLE_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MultiLegReportingType_MULTI_LEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegReportingType_MULTI_LEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiLegReportingType_MULTI_LEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_MULTI_LEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_SICOVAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_SICOVAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_SICOVAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_SICOVAM);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_SEDOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_SEDOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_SEDOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_SEDOL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_CUSIP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_CUSIP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_CUSIP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_CUSIP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_QUIK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_QUIK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_QUIK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_QUIK);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_BELGIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_BELGIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_BELGIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_BELGIAN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_VALOREN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_VALOREN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_VALOREN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_VALOREN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_DUTCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_DUTCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_DUTCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_DUTCH);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_WERTPAPIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_WERTPAPIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_WERTPAPIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_WERTPAPIER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_BLOOMBERG_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_BLOOMBERG_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_BLOOMBERG_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_BLOOMBERG_SYMBOL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_EXCHANGE_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_EXCHANGE_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_EXCHANGE_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_EXCHANGE_SYMBOL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_ISO_COUNTRY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISO_COUNTRY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_ISO_COUNTRY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISO_COUNTRY_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_ISO_CURRENCY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISO_CURRENCY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_ISO_CURRENCY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISO_CURRENCY_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_RIC_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_RIC_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_RIC_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_RIC_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_ISIN_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISIN_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_ISIN_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISIN_NUMBER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_COMMON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_COMMON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_COMMON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_COMMON);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_CLEARING_HOUSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_CLEARING_HOUSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_CLEARING_HOUSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_CLEARING_HOUSE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_ISDA_FP_ML_SPECIFICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISDA_FP_ML_SPECIFICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_ISDA_FP_ML_SPECIFICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISDA_FP_ML_SPECIFICATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_ISDA_FP_MLURL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISDA_FP_MLURL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_ISDA_FP_MLURL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISDA_FP_MLURL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_LETTER_OF_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_LETTER_OF_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_LETTER_OF_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_LETTER_OF_CREDIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_MARKIT_RED_ENTITY_CLIP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_MARKIT_RED_ENTITY_CLIP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_MARKIT_RED_ENTITY_CLIP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_MARKIT_RED_ENTITY_CLIP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_MARKIT_RED_PAIR_CLIP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_MARKIT_RED_PAIR_CLIP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_MARKIT_RED_PAIR_CLIP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_MARKIT_RED_PAIR_CLIP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_CFTC_COMMODITY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_CFTC_COMMODITY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_CFTC_COMMODITY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_CFTC_COMMODITY_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_ISDA_COMMODITY_REFERENCE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISDA_COMMODITY_REFERENCE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_ISDA_COMMODITY_REFERENCE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISDA_COMMODITY_REFERENCE_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_FINANCIAL_INSTRUMENT_GLOBAL_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_FINANCIAL_INSTRUMENT_GLOBAL_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_FINANCIAL_INSTRUMENT_GLOBAL_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_FINANCIAL_INSTRUMENT_GLOBAL_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_LEGAL_ENTITY_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_LEGAL_ENTITY_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_LEGAL_ENTITY_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_LEGAL_ENTITY_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_SYNTHETIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_SYNTHETIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_SYNTHETIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_SYNTHETIC);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_FIDESSA_INSTRUMENT_MNEMONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_FIDESSA_INSTRUMENT_MNEMONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_FIDESSA_INSTRUMENT_MNEMONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_FIDESSA_INSTRUMENT_MNEMONIC);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_INDEX_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_INDEX_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_INDEX_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_INDEX_NAME);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_UNIFORM_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_UNIFORM_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_UNIFORM_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_UNIFORM_SYMBOL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_DIGITAL_TOKEN_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_DIGITAL_TOKEN_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_DIGITAL_TOKEN_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_DIGITAL_TOKEN_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQty_LARGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQty_LARGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQty_LARGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIQty_LARGE);
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQty_MEDIUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQty_MEDIUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQty_MEDIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIQty_MEDIUM);
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQty_SMALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQty_SMALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQty_SMALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIQty_SMALL);
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQty_UNDISCLOSED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQty_UNDISCLOSED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQty_UNDISCLOSED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIQty_UNDISCLOSED_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_PositionEffect_FIFO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_FIFO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionEffect_FIFO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_FIFO));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionEffect_ROLLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_ROLLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionEffect_ROLLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_ROLLED));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionEffect_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionEffect_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionEffect_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionEffect_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionEffect_DEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_DEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionEffect_DEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_DEFAULT));
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_LIBID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_LIBID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_LIBID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_LIBID);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_OTHER);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_TREASURY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_TREASURY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_TREASURY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_TREASURY);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_EURIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_EURIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_EURIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EURIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_PFANDBRIEFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_PFANDBRIEFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_PFANDBRIEFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_PFANDBRIEFE);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_FUTURE_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_FUTURE_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_FUTURE_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_FUTURE_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_MUNI_AAA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_MUNI_AAA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_MUNI_AAA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_MUNI_AAA);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_LIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_LIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_LIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_LIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_EONIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_EONIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_EONIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EONIA);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_EUREPO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_EUREPO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_EUREPO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EUREPO);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_SONIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_SONIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_SONIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_SONIA);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_FED_FUND_RATE_EFFECTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_FED_FUND_RATE_EFFECTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_FED_FUND_RATE_EFFECTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_FED_FUND_RATE_EFFECTIVE);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_FED_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_FED_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_FED_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_FED_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_AUBSW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_AUBSW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_AUBSW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_AUBSW);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_BUBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_BUBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_BUBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_BUBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_CDOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_CDOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_CDOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_CDOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_CIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_CIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_CIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_CIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_EONIASWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_EONIASWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_EONIASWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EONIASWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_ESTR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_ESTR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_ESTR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_ESTR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_EURODOLLAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_EURODOLLAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_EURODOLLAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EURODOLLAR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_EUROSWISS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_EUROSWISS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_EUROSWISS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EUROSWISS);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_GCFREPO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_GCFREPO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_GCFREPO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_GCFREPO);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_ISDAFIX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_ISDAFIX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_ISDAFIX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_ISDAFIX);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_JIBAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_JIBAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_JIBAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_JIBAR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_MOSPRIM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_MOSPRIM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_MOSPRIM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_MOSPRIM);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_NIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_NIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_NIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_NIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_PRIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_PRIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_PRIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_PRIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_SOFR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_SOFR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_SOFR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_SOFR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_STIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_STIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_STIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_STIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_TELBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_TELBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_TELBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_TELBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_TIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_TIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_TIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_TIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_WIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_WIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_WIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_WIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_AONIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_AONIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_AONIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_AONIA);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_AONIAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_AONIAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_AONIAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_AONIAR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_BKBM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_BKBM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_BKBM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_BKBM);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_CD19_D_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_CD19_D is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_CD19_D_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_CD19_D);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_CORRA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_CORRA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_CORRA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_CORRA);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_DIRRTN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_DIRRTN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_DIRRTN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_DIRRTN);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_EIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_EIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_EIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_FIXING_REPO_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_FIXING_REPO_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_FIXING_REPO_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_FIXING_REPO_RATE);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_HIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_HIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_HIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_HIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_IBR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_IBR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_IBR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_IBR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_KLIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_KLIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_KLIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_KLIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_MIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_MIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_MIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_MIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_NZONIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_NZONIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_NZONIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_NZONIA);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_PHIREF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_PHIREF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_PHIREF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_PHIREF);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_REIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_REIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_REIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_REIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_SAIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_SAIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_SAIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_SAIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_SARON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_SARON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_SARON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_SARON);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_SORA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_SORA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_SORA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_SORA);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_TLREF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_TLREF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_TLREF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_TLREF);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_TIIE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_TIIE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_TIIE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_TIIE);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_THBFIX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_THBFIX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_THBFIX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_THBFIX);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_TONAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_TONAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_TONAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_TONAR);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ABSOLUTE_PREPAYMENT_SPEED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ABSOLUTE_PREPAYMENT_SPEED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ABSOLUTE_PREPAYMENT_SPEED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ABSOLUTE_PREPAYMENT_SPEED);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_LOAN_AGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LOAN_AGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WEIGHTED_AVERAGE_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WEIGHTED_AVERAGE_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_MATURITY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_CONSTANT_PREPAYMENT_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CONSTANT_PREPAYMENT_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_CONSTANT_PREPAYMENT_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_RATE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_SINGLE_MONTHLY_MORTALITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SINGLE_MONTHLY_MORTALITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_SINGLE_MONTHLY_MORTALITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SINGLE_MONTHLY_MORTALITY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MONTHLY_PREPAYMENT_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MONTHLY_PREPAYMENT_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MONTHLY_PREPAYMENT_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MONTHLY_PREPAYMENT_RATE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_CONSTANT_PREPAYMENT_PENALTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CONSTANT_PREPAYMENT_PENALTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_CONSTANT_PREPAYMENT_PENALTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_PENALTY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_LOT_VARIANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_LOT_VARIANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_LOT_VARIANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_LOT_VARIANCE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_CONSTANT_PREPAYMENT_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CONSTANT_PREPAYMENT_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_CONSTANT_PREPAYMENT_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WEIGHTED_AVERAGE_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WEIGHTED_AVERAGE_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_COUPON);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ISSUE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ISSUE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ISSUE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ISSUE_DATE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MATURITY_YEAR_AND_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MATURITY_YEAR_AND_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MATURITY_YEAR_AND_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MATURITY_YEAR_AND_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_NUMBER_OF_PIECES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_NUMBER_OF_PIECES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_NUMBER_OF_PIECES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_NUMBER_OF_PIECES);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_POOLS_MAXIMUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLS_MAXIMUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_POOLS_MAXIMUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLS_MAXIMUM);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_POOLS_PER_MILLION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLS_PER_MILLION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_POOLS_PER_MILLION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_MILLION);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_POOLS_PER_LOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLS_PER_LOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_POOLS_PER_LOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_LOT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_POOLS_PER_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLS_PER_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_POOLS_PER_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PRODUCTION_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRODUCTION_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PRODUCTION_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRODUCTION_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_TRADE_VARIANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TRADE_VARIANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_TRADE_VARIANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TRADE_VARIANCE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_GEOGRAPHICS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_GEOGRAPHICS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_GEOGRAPHICS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_GEOGRAPHICS);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ALTERNATIVE_MINIMUM_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ALTERNATIVE_MINIMUM_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ALTERNATIVE_MINIMUM_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ALTERNATIVE_MINIMUM_TAX);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_AUTO_REINVESTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_AUTO_REINVESTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_AUTO_REINVESTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_AUTO_REINVESTMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_BANK_QUALIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BANK_QUALIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_BANK_QUALIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BANK_QUALIFIED);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_BARGAIN_CONDITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BARGAIN_CONDITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_BARGAIN_CONDITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BARGAIN_CONDITIONS);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_COUPON_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_COUPON_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_COUPON_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_COUPON_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ISO_CURRENCY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ISO_CURRENCY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ISO_CURRENCY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ISO_CURRENCY_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_CUSTOM_START_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CUSTOM_START is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_CUSTOM_START_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CUSTOM_START);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_VALUATION_DISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_VALUATION_DISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_VALUATION_DISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_VALUATION_DISCOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_INSURED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_INSURED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_INSURED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_INSURED);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ISSUER);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ISSUE_SIZE_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ISSUE_SIZE_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ISSUE_SIZE_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ISSUE_SIZE_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_LOOKBACK_DAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_LOOKBACK_DAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_LOOKBACK_DAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_LOOKBACK_DAYS);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_EXPLICIT_LOT_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_EXPLICIT_LOT_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_EXPLICIT_LOT_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_EXPLICIT_LOT_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MATURITY_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MATURITY_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MATURITY_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MATURITY_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MAXIMUM_SUBSTITUTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MAXIMUM_SUBSTITUTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MAXIMUM_SUBSTITUTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_SUBSTITUTIONS);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MINIMUM_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MINIMUM_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MINIMUM_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MINIMUM_INCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MINIMUM_INCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MINIMUM_INCREMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_INCREMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MINIMUM_DENOMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MINIMUM_DENOMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MINIMUM_DENOMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_DENOMINATION);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PAYMENT_FREQUENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PAYMENT_FREQUENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PAYMENT_FREQUENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PAYMENT_FREQUENCY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PRICE_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRICE_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PRICE_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRICE_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PRICING_FREQUENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRICING_FREQUENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PRICING_FREQUENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRICING_FREQUENCY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_CALL_PROTECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CALL_PROTECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_CALL_PROTECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CALL_PROTECTION);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PURPOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PURPOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PURPOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PURPOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_BENCHMARK_PRICE_SOURCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BENCHMARK_PRICE_SOURCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_BENCHMARK_PRICE_SOURCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BENCHMARK_PRICE_SOURCE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_RATING_SOURCE_AND_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_RATING_SOURCE_AND_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_RATING_SOURCE_AND_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_RATING_SOURCE_AND_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_TYPE_OF_REDEMPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TYPE_OF_REDEMPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_TYPE_OF_REDEMPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TYPE_OF_REDEMPTION);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_RESTRICTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_RESTRICTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_RESTRICTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_RESTRICTED);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MARKET_SECTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MARKET_SECTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MARKET_SECTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MARKET_SECTOR);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_STRUCTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_STRUCTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_STRUCTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_STRUCTURE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_SUBSTITUTIONS_FREQUENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SUBSTITUTIONS_FREQUENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_SUBSTITUTIONS_FREQUENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTIONS_FREQUENCY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_SUBSTITUTIONS_LEFT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SUBSTITUTIONS_LEFT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_SUBSTITUTIONS_LEFT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTIONS_LEFT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_FREEFORM_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_FREEFORM_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_FREEFORM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_FREEFORM_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WHOLE_POOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WHOLE_POOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WHOLE_POOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WHOLE_POOL);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_YIELD_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_YIELD_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_YIELD_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_YIELD_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_AVERAGE_FICO_SCORE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_AVERAGE_FICO_SCORE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_AVERAGE_FICO_SCORE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_AVERAGE_FICO_SCORE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_AVERAGE_LOAN_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_AVERAGE_LOAN_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_AVERAGE_LOAN_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_AVERAGE_LOAN_SIZE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MAXIMUM_LOAN_BALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MAXIMUM_LOAN_BALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MAXIMUM_LOAN_BALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_LOAN_BALANCE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_POOL_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOL_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_POOL_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOL_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_TYPE_OF_ROLL_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TYPE_OF_ROLL_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_TYPE_OF_ROLL_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TYPE_OF_ROLL_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_BROKER_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BROKER_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_BROKER_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BROKER_CREDIT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MAXIMUM_ORDER_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MAXIMUM_ORDER_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MAXIMUM_ORDER_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_ORDER_SIZE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ORDER_QUANTITY_INCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ORDER_QUANTITY_INCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ORDER_QUANTITY_INCREMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ORDER_QUANTITY_INCREMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_BROKER_SALES_CREDIT_OVERRIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BROKER_SALES_CREDIT_OVERRIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_BROKER_SALES_CREDIT_OVERRIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BROKER_SALES_CREDIT_OVERRIDE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_TRADER_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TRADER_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_TRADER_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TRADER_CREDIT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_DISCOUNT_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_DISCOUNT_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_DISCOUNT_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_DISCOUNT_RATE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_YIELD_TO_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_YIELD_TO_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_YIELD_TO_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_YIELD_TO_MATURITY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ORIGINAL_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ORIGINAL_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ORIGINAL_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ORIGINAL_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_POOL_EFFECTIVE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOL_EFFECTIVE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_POOL_EFFECTIVE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOL_EFFECTIVE_DATE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_POOL_INITIAL_FACTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOL_INITIAL_FACTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_POOL_INITIAL_FACTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOL_INITIAL_FACTOR);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_TRANCHE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TRANCHE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_TRANCHE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TRANCHE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_SUBSTITUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SUBSTITUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_SUBSTITUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTION);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MULTEXCHFLLBCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MULTEXCHFLLBCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MULTEXCHFLLBCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MULTEXCHFLLBCK);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_COMPSECFLLBCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_COMPSECFLLBCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_COMPSECFLLBCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_COMPSECFLLBCK);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_LOCLJRSDCTN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_LOCLJRSDCTN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_LOCLJRSDCTN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_LOCLJRSDCTN);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_RELVJRSDCTN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_RELVJRSDCTN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_RELVJRSDCTN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_RELVJRSDCTN);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_INCURRED_RECOVERY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_INCURRED_RECOVERY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_INCURRED_RECOVERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_INCURRED_RECOVERY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ADDITIONAL_TERM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ADDITIONAL_TERM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ADDITIONAL_TERM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ADDITIONAL_TERM);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MODIFIED_EQUITY_DELIVERY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MODIFIED_EQUITY_DELIVERY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MODIFIED_EQUITY_DELIVERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MODIFIED_EQUITY_DELIVERY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_NO_REFERENCE_OBLICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_NO_REFERENCE_OBLICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_NO_REFERENCE_OBLICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_NO_REFERENCE_OBLICATION);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_UNKNOWN_REFERENCE_OBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_UNKNOWN_REFERENCE_OBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_UNKNOWN_REFERENCE_OBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_UNKNOWN_REFERENCE_OBLIGATION);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ALL_GUARANTEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ALL_GUARANTEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ALL_GUARANTEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ALL_GUARANTEES);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_REFERENCE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_REFERENCE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_REFERENCE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_REFERENCE_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_REFERENCE_POLICY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_REFERENCE_POLICY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_REFERENCE_POLICY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_REFERENCE_POLICY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_SECURED_LIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SECURED_LIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_SECURED_LIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SECURED_LIST);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_INTEREST_PAYOFF_OF_ROLLING_OR_AMENDING_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_INTEREST_PAYOFF_OF_ROLLING_OR_AMENDING_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_INTEREST_PAYOFF_OF_ROLLING_OR_AMENDING_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_INTEREST_PAYOFF_OF_ROLLING_OR_AMENDING_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_TRUE_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TRUE_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_TRUE_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TRUE_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_PREVIOUS_CLOSE_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_PREVIOUS_CLOSE_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_PREVIOUS_CLOSE_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_PREVIOUS_CLOSE_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_LONGEST_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_LONGEST_AVERAGE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_MATURITY);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_MARK_TO_MARKET_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_MARK_TO_MARKET_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_MARK_TO_MARKET_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_MARK_TO_MARKET_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_OPEN_AVERAGE_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_OPEN_AVERAGE_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_OPEN_AVERAGE_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_OPEN_AVERAGE_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_NEXT_PUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_NEXT_PUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_NEXT_PUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_PUT);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_PROCEEDS_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_PROCEEDS_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_PROCEEDS_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_PROCEEDS_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_SEMI_ANNUAL_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_SEMI_ANNUAL_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_SEMI_ANNUAL_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_SEMI_ANNUAL_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_SHORTEST_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_SHORTEST_AVERAGE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_SIMPLE_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_SIMPLE_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_SIMPLE_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_SIMPLE_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_TENDER_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_TENDER_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_TENDER_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_TENDER_DATE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_VALUE_OF32NDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_VALUE_OF32NDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_VALUE_OF32NDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_VALUE_OF32NDS);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_WORST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_WORST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_WORST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_WORST);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_TAX_EQUIVALENT_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TAX_EQUIVALENT_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_TAX_EQUIVALENT_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TAX_EQUIVALENT_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_ANNUAL_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_ANNUAL_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_ANNUAL_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_ANNUAL_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSING_YIELD_MOST_RECENT_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_NEXT_REFUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_NEXT_REFUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_NEXT_REFUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_REFUND);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_AFTER_TAX_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_AFTER_TAX_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_AFTER_TAX_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_AFTER_TAX_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_AT_ISSUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_AT_ISSUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_AT_ISSUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_AT_ISSUE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_AVERAGE_LIFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_AVERAGE_LIFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_AVERAGE_LIFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_AVERAGE_LIFE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_AVERAGE_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_AVERAGE_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_AVERAGE_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_AVERAGE_MATURITY);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_BOOK_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_BOOK_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_BOOK_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_BOOK_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_NEXT_CALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_NEXT_CALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_NEXT_CALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_CALL);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_CHANGE_SINCE_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_CHANGE_SINCE_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_CHANGE_SINCE_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_CHANGE_SINCE_CLOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_COMPOUND_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_COMPOUND_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_COMPOUND_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_COMPOUND_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CURRENT_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CURRENT_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CURRENT_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CURRENT_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_TRUE_GROSS_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TRUE_GROSS_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_TRUE_GROSS_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TRUE_GROSS_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_GVNT_EQUIVALENT_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_GVNT_EQUIVALENT_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_GVNT_EQUIVALENT_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_GVNT_EQUIVALENT_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_WITH_INFLATION_ASSUMPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_WITH_INFLATION_ASSUMPTION);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_INVERSE_FLOATER_BOND_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_INVERSE_FLOATER_BOND_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_INVERSE_FLOATER_BOND_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_INVERSE_FLOATER_BOND_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_MOST_RECENT_CLOSING_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_MOST_RECENT_CLOSING_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_MOST_RECENT_CLOSING_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_MOST_RECENT_CLOSING_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSING_YIELD_MOST_RECENT_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CLOSING_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSING_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CLOSING_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_VALUE_OF132_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_VALUE_OF132 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_VALUE_OF132_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_VALUE_OF132);
  return pyobj;
}


SWIGINTERN int Swig_var_TradedFlatSwitch_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradedFlatSwitch_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradedFlatSwitch_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradedFlatSwitch_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_TradedFlatSwitch_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradedFlatSwitch_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradedFlatSwitch_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradedFlatSwitch_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_REMOVED_FROM_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_REMOVED_FROM_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_REMOVED_FROM_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_REMOVED_FROM_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCEL_FOR_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCEL_FOR_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCEL_FOR_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCEL_FOR_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_QUOTE_NOT_FOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_QUOTE_NOT_FOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_QUOTE_NOT_FOUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_QUOTE_NOT_FOUND));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_QUERY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_QUERY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_QUERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_QUERY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCELED_ALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_ALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCELED_ALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_ALL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCELED_FOR_UNDERLYING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_FOR_UNDERLYING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCELED_FOR_UNDERLYING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_FOR_UNDERLYING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCELED_FOR_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_FOR_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCELED_FOR_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_FOR_SECURITY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_PASS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_PASS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_PASS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_PASS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_LOCKED_MARKET_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_LOCKED_MARKET_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_LOCKED_MARKET_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_LOCKED_MARKET_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CROSS_MARKET_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CROSS_MARKET_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CROSS_MARKET_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CROSS_MARKET_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_ACTIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCELED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCELED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_PENDING_END_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_PENDING_END_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_PENDING_END_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_PENDING_END_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_TOO_LATE_TO_END_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_TOO_LATE_TO_END is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_TOO_LATE_TO_END_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_TOO_LATE_TO_END));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_TRADED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_TRADED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_TRADED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_TRADED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_TRADED_AND_REMOVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_TRADED_AND_REMOVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_TRADED_AND_REMOVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_TRADED_AND_REMOVED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CONTRACT_TERMINATES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CONTRACT_TERMINATES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CONTRACT_TERMINATES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CONTRACT_TERMINATES));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_CHINESE_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_CHINESE_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_CHINESE_INVESTOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_CHINESE_INVESTOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_ISO_COUNTRY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_ISO_COUNTRY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_ISO_COUNTRY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_ISO_COUNTRY_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_BIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_BIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_BIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_BIC));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_US_SOCIAL_SECURITY_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_US_SOCIAL_SECURITY_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_US_SOCIAL_SECURITY_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_US_SOCIAL_SECURITY_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_PROPRIETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_PROPRIETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_PROPRIETARY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_SETTLEMENT_ENTITY_LOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_SETTLEMENT_ENTITY_LOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_SETTLEMENT_ENTITY_LOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_SETTLEMENT_ENTITY_LOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_KOREAN_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_KOREAN_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_KOREAN_INVESTOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_KOREAN_INVESTOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_TAIWANESE_FOREIGN_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_TAIWANESE_FOREIGN_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_TAIWANESE_FOREIGN_INVESTOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAIWANESE_FOREIGN_INVESTOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_TAIWANESE_TRADING_ACCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_TAIWANESE_TRADING_ACCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_TAIWANESE_TRADING_ACCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAIWANESE_TRADING_ACCT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_GENERAL_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_GENERAL_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_GENERAL_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_GENERAL_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_MIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_MIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_MIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_MIC));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_CSD_PARTICIPANT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_CSD_PARTICIPANT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_CSD_PARTICIPANT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_CSD_PARTICIPANT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_ISITC_ACRONYM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_ISITC_ACRONYM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_ISITC_ACRONYM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_ISITC_ACRONYM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_TAX_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_TAX_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_TAX_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAX_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_AUSTRALIAN_COMPANY_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_AUSTRALIAN_COMPANY_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_AUSTRALIAN_COMPANY_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_AUSTRALIAN_COMPANY_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_AUSTRALIAN_REGISTERED_BODY_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_AUSTRALIAN_REGISTERED_BODY_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_AUSTRALIAN_REGISTERED_BODY_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_AUSTRALIAN_REGISTERED_BODY_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_CFTC_REPORTING_FIRM_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_CFTC_REPORTING_FIRM_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_CFTC_REPORTING_FIRM_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_CFTC_REPORTING_FIRM_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_LEGAL_ENTITY_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_LEGAL_ENTITY_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_LEGAL_ENTITY_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_LEGAL_ENTITY_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_INTERIM_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_INTERIM_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_INTERIM_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_INTERIM_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_SHORT_CODE_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_SHORT_CODE_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_SHORT_CODE_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_SHORT_CODE_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_NATIONAL_ID_NATURAL_PERSON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_NATIONAL_ID_NATURAL_PERSON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_NATIONAL_ID_NATURAL_PERSON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_NATIONAL_ID_NATURAL_PERSON));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_INDIA_PERMANENT_ACCOUNT_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_INDIA_PERMANENT_ACCOUNT_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_INDIA_PERMANENT_ACCOUNT_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_INDIA_PERMANENT_ACCOUNT_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_FDID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_FDID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_FDID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_FDID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_SPSAID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_SPSAID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_SPSAID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_SPSAID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_MASTER_SPSAID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_MASTER_SPSAID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_MASTER_SPSAID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_MASTER_SPSAID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CORRESPONDANT_CLEARING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CORRESPONDANT_CLEARING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CORRESPONDANT_CLEARING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDANT_CLEARING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CLIENT_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CLIENT_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CLIENT_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLIENT_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_UNDERLYING_CONTRA_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_UNDERLYING_CONTRA_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_UNDERLYING_CONTRA_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_UNDERLYING_CONTRA_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SPONSORING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SPONSORING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SPONSORING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SPONSORING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CONTRA_CLEARING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_CLEARING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CONTRA_CLEARING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_CLEARING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CONTRA_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CONTRA_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXECUTING_SYSTEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXECUTING_SYSTEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXECUTING_SYSTEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_SYSTEM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ENTERING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ENTERING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ENTERING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXECUTING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXECUTING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXECUTING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_BROKER_OF_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_BROKER_OF_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_BROKER_OF_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BROKER_OF_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INVESTOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INVESTOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INTRODUCING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INTRODUCING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INTRODUCING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTRODUCING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_GIVEUP_CLEARING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_GIVEUP_CLEARING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_GIVEUP_CLEARING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_GIVEUP_CLEARING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_LOCATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_LOCATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_LOCATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LOCATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_FUND_MANAGER_CLIENT_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_FUND_MANAGER_CLIENT_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_FUND_MANAGER_CLIENT_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_FUND_MANAGER_CLIENT_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SETTLEMENT_LOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SETTLEMENT_LOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SETTLEMENT_LOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SETTLEMENT_LOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ORDER_ORIGINATION_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ORDER_ORIGINATION_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ORDER_ORIGINATION_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ORDER_ORIGINATION_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXECUTING_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXECUTING_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXECUTING_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ORDER_ORIGINATION_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ORDER_ORIGINATION_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ORDER_ORIGINATION_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ORDER_ORIGINATION_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CLEARING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CLEARING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CLEARING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CLEARING_ORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CLEARING_ORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CLEARING_ORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_ORGANIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CUSTOMER_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CUSTOMER_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CUSTOMER_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CUSTOMER_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CORRESPONDENT_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CORRESPONDENT_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CORRESPONDENT_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDENT_BROKER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_BUYER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_BUYER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_BUYER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BUYER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CUSTODIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CUSTODIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CUSTODIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CUSTODIAN));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_AGENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SUB_CUSTODIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SUB_CUSTODIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SUB_CUSTODIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SUB_CUSTODIAN));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_BENEFICIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_BENEFICIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_BENEFICIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BENEFICIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INTERESTED_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INTERESTED_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INTERESTED_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERESTED_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_REGULATORY_BODY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_REGULATORY_BODY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_REGULATORY_BODY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REGULATORY_BODY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_LIQUIDITY_PROVIDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_LIQUIDITY_PROVIDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_LIQUIDITY_PROVIDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LIQUIDITY_PROVIDER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ENTERING_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ENTERING_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ENTERING_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CONTRA_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CONTRA_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_POSITION_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_POSITION_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_POSITION_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_POSITION_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CONTRA_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CONTRA_INVESTOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_INVESTOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_TRANSFER_TO_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_TRANSFER_TO_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_TRANSFER_TO_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_TRANSFER_TO_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CONTRA_POSITION_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_POSITION_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CONTRA_POSITION_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_POSITION_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CONTRA_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CONTRA_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INTERNAL_CARRY_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INTERNAL_CARRY_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INTERNAL_CARRY_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERNAL_CARRY_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ORDER_ENTRY_OPERATOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ORDER_ENTRY_OPERATOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ORDER_ENTRY_OPERATOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ORDER_ENTRY_OPERATOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SECONDARY_ACCOUNT_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SECONDARY_ACCOUNT_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SECONDARY_ACCOUNT_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SECONDARY_ACCOUNT_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_FOREIGN_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_FOREIGN_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_FOREIGN_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_FOREIGN_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_THIRD_PARTY_ALLOCATION_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_THIRD_PARTY_ALLOCATION_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_THIRD_PARTY_ALLOCATION_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_THIRD_PARTY_ALLOCATION_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CLAIMING_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CLAIMING_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CLAIMING_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLAIMING_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ASSET_MANAGER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ASSET_MANAGER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ASSET_MANAGER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ASSET_MANAGER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_PLEDGOR_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_PLEDGOR_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_PLEDGOR_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_PLEDGOR_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_PLEDGEE_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_PLEDGEE_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_PLEDGEE_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_PLEDGEE_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_TRADER_MNEMONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_TRADER_MNEMONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_TRADER_MNEMONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_TRADER_MNEMONIC));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SENDER_LOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SENDER_LOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SENDER_LOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SENDER_LOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SESSION_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SESSION_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SESSION_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SESSION_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ACCEPTABLE_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ACCEPTABLE_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ACCEPTABLE_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ACCEPTABLE_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_UNACCEPTABLE_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_UNACCEPTABLE_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_UNACCEPTABLE_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_UNACCEPTABLE_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ENTERING_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ENTERING_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ENTERING_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXECUTING_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXECUTING_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXECUTING_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INTRODUCING_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INTRODUCING_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INTRODUCING_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTRODUCING_BROKER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_QUOTE_ORIGINATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_QUOTE_ORIGINATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_QUOTE_ORIGINATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_QUOTE_ORIGINATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_REPORT_ORIGINATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_REPORT_ORIGINATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_REPORT_ORIGINATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REPORT_ORIGINATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SYSTEMATIC_INTERNALISER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SYSTEMATIC_INTERNALISER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SYSTEMATIC_INTERNALISER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SYSTEMATIC_INTERNALISER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_MULTILATERAL_TRADING_FACILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_MULTILATERAL_TRADING_FACILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_MULTILATERAL_TRADING_FACILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_MULTILATERAL_TRADING_FACILITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_REGULATED_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_REGULATED_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_REGULATED_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REGULATED_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INVESTMENT_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INVESTMENT_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INVESTMENT_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INVESTMENT_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_HOST_COMPETENT_AUTHORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_HOST_COMPETENT_AUTHORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_HOST_COMPETENT_AUTHORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_HOST_COMPETENT_AUTHORITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_HOME_COMPETENT_AUTHORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_HOME_COMPETENT_AUTHORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_HOME_COMPETENT_AUTHORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_HOME_COMPETENT_AUTHORITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_COMPETENT_AUTHORITY_LIQUIDITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_COMPETENT_AUTHORITY_LIQUIDITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_COMPETENT_AUTHORITY_LIQUIDITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_COMPETENT_AUTHORITY_LIQUIDITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_COMPETENT_AUTHORITY_TRANSACTION_VENUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_COMPETENT_AUTHORITY_TRANSACTION_VENUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_COMPETENT_AUTHORITY_TRANSACTION_VENUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_COMPETENT_AUTHORITY_TRANSACTION_VENUE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_REPORTING_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_REPORTING_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_REPORTING_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REPORTING_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXECUTION_VENUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXECUTION_VENUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXECUTION_VENUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTION_VENUE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_MARKET_DATA_ENTRY_ORIGINATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_MARKET_DATA_ENTRY_ORIGINATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_MARKET_DATA_ENTRY_ORIGINATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_MARKET_DATA_ENTRY_ORIGINATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_LOCATION_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_LOCATION_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_LOCATION_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LOCATION_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_DESK_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_DESK_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_DESK_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_DESK_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_MARKET_DATA_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_MARKET_DATA_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_MARKET_DATA_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_MARKET_DATA_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ALLOCATION_ENTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ALLOCATION_ENTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ALLOCATION_ENTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ALLOCATION_ENTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_PRIME_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_PRIME_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_PRIME_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_PRIME_BROKER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_STEP_OUT_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_STEP_OUT_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_STEP_OUT_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_STEP_OUT_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_BROKER_CLEARING_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_BROKER_CLEARING_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_BROKER_CLEARING_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BROKER_CLEARING_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_GIVEUP_CLEARING_FIRM_DEPR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_GIVEUP_CLEARING_FIRM_DEPR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_GIVEUP_CLEARING_FIRM_DEPR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_GIVEUP_CLEARING_FIRM_DEPR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CENTRAL_REGISTRATION_DEPOSITORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CENTRAL_REGISTRATION_DEPOSITORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CENTRAL_REGISTRATION_DEPOSITORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CENTRAL_REGISTRATION_DEPOSITORY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CLEARING_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CLEARING_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CLEARING_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CLS_MEMBER_BANK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CLS_MEMBER_BANK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CLS_MEMBER_BANK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLS_MEMBER_BANK));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_IN_CONCERT_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_IN_CONCERT_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_IN_CONCERT_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_IN_CONCERT_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_IN_CONCERT_CONTROLLING_ENTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_IN_CONCERT_CONTROLLING_ENTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_IN_CONCERT_CONTROLLING_ENTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_IN_CONCERT_CONTROLLING_ENTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_LARGE_POSITIONS_REPORTING_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_LARGE_POSITIONS_REPORTING_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_LARGE_POSITIONS_REPORTING_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LARGE_POSITIONS_REPORTING_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SETTLEMENT_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SETTLEMENT_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SETTLEMENT_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SETTLEMENT_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SETTLEMENT_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SETTLEMENT_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SETTLEMENT_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SETTLEMENT_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_REPORTING_MARKET_CENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_REPORTING_MARKET_CENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_REPORTING_MARKET_CENTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REPORTING_MARKET_CENTER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_RELATED_REPORTING_MARKET_CENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_RELATED_REPORTING_MARKET_CENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_RELATED_REPORTING_MARKET_CENTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_RELATED_REPORTING_MARKET_CENTER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_AWAY_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_AWAY_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_AWAY_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_AWAY_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_GIVEUP_TRADING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_GIVEUP_TRADING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_GIVEUP_TRADING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_GIVEUP_TRADING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_TAKEUP_TRADING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_TAKEUP_TRADING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_TAKEUP_TRADING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_TAKEUP_TRADING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_TAKEUP_CLEARING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_TAKEUP_CLEARING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_TAKEUP_CLEARING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_TAKEUP_CLEARING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ORIGINATING_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ORIGINATING_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ORIGINATING_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ORIGINATING_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_MARGIN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_MARGIN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_MARGIN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_MARGIN_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_COLLATERAL_ASSET_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_COLLATERAL_ASSET_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_COLLATERAL_ASSET_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_COLLATERAL_ASSET_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_DATA_REPOSITORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_DATA_REPOSITORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_DATA_REPOSITORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_DATA_REPOSITORY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CALCULATION_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CALCULATION_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CALCULATION_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CALCULATION_AGENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXERCISE_NOTICE_SENDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXERCISE_NOTICE_SENDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXERCISE_NOTICE_SENDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXERCISE_NOTICE_SENDER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXERCISE_NOTICE_RECEIVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXERCISE_NOTICE_RECEIVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXERCISE_NOTICE_RECEIVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXERCISE_NOTICE_RECEIVER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_RATE_REFERENCE_BANK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_RATE_REFERENCE_BANK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_RATE_REFERENCE_BANK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_RATE_REFERENCE_BANK));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CORRESPONDENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CORRESPONDENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CORRESPONDENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_BENEFICIARY_BANK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_BENEFICIARY_BANK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_BENEFICIARY_BANK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BENEFICIARY_BANK));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_BORROWER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_BORROWER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_BORROWER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BORROWER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_PRIMARY_OBLIGATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_PRIMARY_OBLIGATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_PRIMARY_OBLIGATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_PRIMARY_OBLIGATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_GUARANTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_GUARANTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_GUARANTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_GUARANTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXCLUDED_REFERENCE_ENTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXCLUDED_REFERENCE_ENTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXCLUDED_REFERENCE_ENTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXCLUDED_REFERENCE_ENTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_DETERMINING_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_DETERMINING_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_DETERMINING_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_DETERMINING_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_HEDGING_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_HEDGING_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_HEDGING_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_HEDGING_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_REPORTING_ENTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_REPORTING_ENTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_REPORTING_ENTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REPORTING_ENTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SALES_PERSON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SALES_PERSON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SALES_PERSON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SALES_PERSON));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_OPERATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_OPERATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_OPERATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_OPERATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CSD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CSD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CSD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CSD));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ICSD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ICSD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ICSD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ICSD));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_TRADING_SUB_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_TRADING_SUB_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_TRADING_SUB_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_TRADING_SUB_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INVESTMENT_DECISION_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INVESTMENT_DECISION_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INVESTMENT_DECISION_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INVESTMENT_DECISION_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_PUBLISHING_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_PUBLISHING_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_PUBLISHING_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_PUBLISHING_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CSD_PARTICIPANT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CSD_PARTICIPANT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CSD_PARTICIPANT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CSD_PARTICIPANT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CONTRA_CUSTOMER_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_CUSTOMER_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CONTRA_CUSTOMER_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_CUSTOMER_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CONTRA_INVESTMENT_DECISION_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_INVESTMENT_DECISION_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CONTRA_INVESTMENT_DECISION_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_INVESTMENT_DECISION_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_LOAN));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_MUNICIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_MUNICIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_MUNICIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_MUNICIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_AGENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_CORPORATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_CORPORATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_CORPORATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_CORPORATE));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_CURRENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_COMMODITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_COMMODITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_COMMODITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_COMMODITY));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_GOVERNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_GOVERNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_GOVERNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_GOVERNMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_MORTGAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_MORTGAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_MORTGAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_MORTGAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_INDEX));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_MONEYMARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_MONEYMARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_MONEYMARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_MONEYMARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_EQUITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_EQUITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_EQUITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_EQUITY));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_FINANCING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_FINANCING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_FINANCING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_FINANCING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_CONTRACTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_CONTRACTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_CONTRACTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_CONTRACTS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_CURRENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_ORIGINALFACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_ORIGINALFACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_ORIGINALFACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_ORIGINALFACE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_CURRENTFACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_CURRENTFACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_CURRENTFACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_CURRENTFACE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_BONDS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_SHARES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_SHARES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_SHARES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_SHARES));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_PAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_PAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_PAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_PAR));
  return pyobj;
}


SWIGINTERN int Swig_var_RoundingDirection_ROUND_TO_NEAREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoundingDirection_ROUND_TO_NEAREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoundingDirection_ROUND_TO_NEAREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUND_TO_NEAREST));
  return pyobj;
}


SWIGINTERN int Swig_var_RoundingDirection_ROUND_DOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoundingDirection_ROUND_DOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoundingDirection_ROUND_DOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUND_DOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_RoundingDirection_ROUND_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoundingDirection_ROUND_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoundingDirection_ROUND_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUND_UP));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_CREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_CREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_CREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CREST));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_NSCC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_NSCC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_NSCC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_NSCC));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_EUROCLEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_EUROCLEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_EUROCLEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_EUROCLEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_CLEARSTREAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_CLEARSTREAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_CLEARSTREAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CLEARSTREAM));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_CHEQUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_CHEQUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_CHEQUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CHEQUE));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_TELEGRAPHIC_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_TELEGRAPHIC_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_TELEGRAPHIC_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_TELEGRAPHIC_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_FED_WIRE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_FED_WIRE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_FED_WIRE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_FED_WIRE));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_DIRECT_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_DIRECT_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_DIRECT_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_DIRECT_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_ACH_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_ACH_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_ACH_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_ACH_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_BPAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_BPAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_BPAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_BPAY));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_REINVEST_IN_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_REINVEST_IN_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_REINVEST_IN_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_REINVEST_IN_FUND));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_CancellationRights_NO_WAIVER_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_WAIVER_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CancellationRights_NO_WAIVER_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_WAIVER_AGREEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CancellationRights_NO_EXECUTION_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_EXECUTION_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CancellationRights_NO_EXECUTION_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_EXECUTION_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_CancellationRights_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CancellationRights_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_CancellationRights_NO_INSTITUTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_INSTITUTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CancellationRights_NO_INSTITUTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_INSTITUTIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_MoneyLaunderingStatus_EXEMPT_AUTHORISED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXEMPT_AUTHORISED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MoneyLaunderingStatus_EXEMPT_AUTHORISED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_AUTHORISED));
  return pyobj;
}


SWIGINTERN int Swig_var_MoneyLaunderingStatus_EXEMPT_MONEY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXEMPT_MONEY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MoneyLaunderingStatus_EXEMPT_MONEY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_MONEY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MoneyLaunderingStatus_EXEMPT_BELOW_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXEMPT_BELOW_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MoneyLaunderingStatus_EXEMPT_BELOW_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_BELOW_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_MoneyLaunderingStatus_PASSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_PASSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MoneyLaunderingStatus_PASSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_PASSED));
  return pyobj;
}


SWIGINTERN int Swig_var_MoneyLaunderingStatus_NOT_CHECKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_NOT_CHECKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MoneyLaunderingStatus_NOT_CHECKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_NOT_CHECKED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_SINGLE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_SINGLE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_SINGLE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_SINGLE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_OFFER_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_OFFER_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_OFFER_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFER_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_CREATION_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_CREATION_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_CREATION_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATION_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_BID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_BID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_BID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_BID_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportTransType_RELEASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportTransType_RELEASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportTransType_RELEASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_RELEASE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportTransType_REVERSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportTransType_REVERSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportTransType_REVERSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_REVERSE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_BPAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_BPAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_BPAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_BPAY));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_ACH_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_ACH_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_ACH_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_ACH_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_ACH_DEBIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_ACH_DEBIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_ACH_DEBIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_ACH_DEBIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_CREDIT_CARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CREDIT_CARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_CREDIT_CARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CREDIT_CARD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_DIRECT_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_DIRECT_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_DIRECT_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DIRECT_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_DIRECT_DEBIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_DIRECT_DEBIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_DIRECT_DEBIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DIRECT_DEBIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_DEBIT_CARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_DEBIT_CARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_DEBIT_CARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DEBIT_CARD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_FED_WIRE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_FED_WIRE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_FED_WIRE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_FED_WIRE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_EUROCLEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_EUROCLEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_EUROCLEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_EUROCLEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_TELEGRAPHIC_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_TELEGRAPHIC_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_TELEGRAPHIC_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_TELEGRAPHIC_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_CLEARSTREAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CLEARSTREAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_CLEARSTREAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CLEARSTREAM));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_CREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_CREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CREST));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_NSCC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_NSCC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_NSCC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_NSCC));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_CHEQUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CHEQUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_CHEQUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CHEQUE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_CHIPS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CHIPS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_CHIPS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CHIPS));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_SWIFT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_SWIFT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_SWIFT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_SWIFT));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_CHAPS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CHAPS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_CHAPS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CHAPS));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_SIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_SIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_SIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_SIC));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_EURO_SIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_EURO_SIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_EURO_SIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_EURO_SIC));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_PROFIT_SHARING_PLAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_PROFIT_SHARING_PLAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_PROFIT_SHARING_PLAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_PROFIT_SHARING_PLAN));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EMPLOYER_PRIOR_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYER_PRIOR_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EMPLOYER_PRIOR_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER_PRIOR_YEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EMPLOYER_CURRENT_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYER_CURRENT_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EMPLOYER_CURRENT_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER_CURRENT_YEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_NON_FUND_PROTOTYPE_IRA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_NON_FUND_PROTOTYPE_IRA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_NON_FUND_PROTOTYPE_IRA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NON_FUND_PROTOTYPE_IRA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_NON_FUND_QUALIFIED_PLAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_NON_FUND_QUALIFIED_PLAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_NON_FUND_QUALIFIED_PLAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NON_FUND_QUALIFIED_PLAN));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EMPLOYEE_CURRENT_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYEE_CURRENT_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EMPLOYEE_CURRENT_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE_CURRENT_YEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_IRA_ROLLOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_IRA_ROLLOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_IRA_ROLLOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_IRA_ROLLOVER));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_MINI_INSURANCE_ISA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MINI_INSURANCE_ISA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_MINI_INSURANCE_ISA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINI_INSURANCE_ISA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_IRA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_IRA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_IRA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_IRA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EMPLOYEE_PRIOR_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYEE_PRIOR_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EMPLOYEE_PRIOR_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE_PRIOR_YEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_ASSET_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ASSET_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_ASSET_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ASSET_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_SELF_DIRECTED_IRA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_SELF_DIRECTED_IRA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_SELF_DIRECTED_IRA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_SELF_DIRECTED_IRA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_CURRENT_YEAR_PAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_CURRENT_YEAR_PAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_CURRENT_YEAR_PAYMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_CURRENT_YEAR_PAYMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_US401_K_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_US401_K is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_US401_K_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_US401_K));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_MINI_CASH_ISA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MINI_CASH_ISA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_MINI_CASH_ISA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINI_CASH_ISA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_TESSA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_TESSA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_TESSA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_TESSA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_MAXI_ISA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MAXI_ISA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_MAXI_ISA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MAXI_ISA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_PRIOR_YEAR_PAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_PRIOR_YEAR_PAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_PRIOR_YEAR_PAYMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_PRIOR_YEAR_PAYMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_US457_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_US457 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_US457_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_US457));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_ROTH_IRA_PROTOTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTH_IRA_PROTOTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_ROTH_IRA_PROTOTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTH_IRA_PROTOTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_ROTH_IRA_NON_PROTOTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTH_IRA_NON_PROTOTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_ROTH_IRA_NON_PROTOTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTH_IRA_NON_PROTOTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_PROTOTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTH_CONVERSION_IRA_PROTOTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_PROTOTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTH_CONVERSION_IRA_PROTOTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_NON_PROTOTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTH_CONVERSION_IRA_NON_PROTOTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_NON_PROTOTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTH_CONVERSION_IRA_NON_PROTOTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EDUCATION_IRA_PROTOTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EDUCATION_IRA_PROTOTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EDUCATION_IRA_PROTOTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EDUCATION_IRA_PROTOTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EDUCATION_IRA_NON_PROTOTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EDUCATION_IRA_NON_PROTOTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EDUCATION_IRA_NON_PROTOTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EDUCATION_IRA_NON_PROTOTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_KEOGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_KEOGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_KEOGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_KEOGH));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_US403B_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_US403B is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_US403B_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_US403B));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_FundRenewWaiv_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FundRenewWaiv_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FundRenewWaiv_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FundRenewWaiv_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_FundRenewWaiv_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FundRenewWaiv_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FundRenewWaiv_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FundRenewWaiv_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistStatus_REMINDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_REMINDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistStatus_REMINDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REMINDER));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistStatus_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistStatus_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_HELD));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_DISTRIB_INSTNS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_DISTRIB_INSTNS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_DISTRIB_INSTNS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_DISTRIB_INSTNS));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_AGENT_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_AGENT_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_AGENT_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_AGENT_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_ACCOUNT_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_ACCOUNT_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_ACCOUNT_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_ACCOUNT_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_NO_REG_DETAILS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_NO_REG_DETAILS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_NO_REG_DETAILS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_NO_REG_DETAILS));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_PAYMENT_METHOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_PAYMENT_METHOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_PAYMENT_METHOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_PAYMENT_METHOD));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_OWNERSHIP_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_OWNERSHIP_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_OWNERSHIP_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_OWNERSHIP_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_TAX_EXEMPT_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_TAX_EXEMPT_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_TAX_EXEMPT_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_TAX_EXEMPT_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_COUNTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_COUNTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_COUNTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_COUNTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_DATE_OF_BIRTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_DATE_OF_BIRTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_DATE_OF_BIRTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_DATE_OF_BIRTH));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_INVESTOR_ID_SOURCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_INVESTOR_ID_SOURCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_INVESTOR_ID_SOURCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_INVESTOR_ID_SOURCE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_INVESTOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_INVESTOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_MAILING_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_MAILING_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_MAILING_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_MAILING_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_MAILING_DETAILS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_MAILING_DETAILS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_MAILING_DETAILS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_MAILING_DETAILS));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_REG_SEQ_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_REG_SEQ_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_REG_SEQ_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_REG_SEQ_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_ACCOUNT_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_ACCOUNT_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_ACCOUNT_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_ACCOUNT_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_ACCOUNT_NUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_ACCOUNT_NUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_ACCOUNT_NUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_ACCOUNT_NUM));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_REG_DETAILS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_REG_DETAILS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_REG_DETAILS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_REG_DETAILS));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnershipType_JOINT_INVESTORS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnershipType_JOINT_INVESTORS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnershipType_JOINT_INVESTORS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OwnershipType_JOINT_INVESTORS));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnershipType_TENANTS_IN_COMMON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnershipType_TENANTS_IN_COMMON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnershipType_TENANTS_IN_COMMON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OwnershipType_TENANTS_IN_COMMON));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnershipType_JOINT_TRUSTEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnershipType_JOINT_TRUSTEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnershipType_JOINT_TRUSTEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OwnershipType_JOINT_TRUSTEES));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_NET_SETTLEMENT_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_NET_SETTLEMENT_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_NET_SETTLEMENT_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_NET_SETTLEMENT_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_COMMISSION_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_COMMISSION_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_COMMISSION_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSION_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_COMMISSION_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_COMMISSION_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_COMMISSION_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSION_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_INITIAL_CHARGE_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_INITIAL_CHARGE_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_INITIAL_CHARGE_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_INITIAL_CHARGE_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_INITIAL_CHARGE_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_INITIAL_CHARGE_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_INITIAL_CHARGE_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_INITIAL_CHARGE_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_DISCOUNT_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DISCOUNT_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_DISCOUNT_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNT_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_DISCOUNT_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DISCOUNT_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_DISCOUNT_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNT_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_DILUTION_LEVY_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DILUTION_LEVY_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_DILUTION_LEVY_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DILUTION_LEVY_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_DILUTION_LEVY_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DILUTION_LEVY_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_DILUTION_LEVY_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DILUTION_LEVY_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_EXIT_CHARGE_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_EXIT_CHARGE_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_EXIT_CHARGE_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_EXIT_CHARGE_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_EXIT_CHARGE_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_EXIT_CHARGE_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_EXIT_CHARGE_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_EXIT_CHARGE_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_PROJECTED_FUND_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_PROJECTED_FUND_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_PROJECTED_FUND_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_PROJECTED_FUND_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_ON_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_FUND_BASED_RENEWAL_COMMISSION_ON_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_ON_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUND_BASED_RENEWAL_COMMISSION_ON_FUND));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_ON_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_FUND_BASED_RENEWAL_COMMISSION_ON_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_ON_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUND_BASED_RENEWAL_COMMISSION_ON_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_COMPANY_TRUSTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_COMPANY_TRUSTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_COMPANY_TRUSTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_COMPANY_TRUSTEE));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_NOMINEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_NOMINEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_NOMINEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_NOMINEE));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_CORPORATE_BODY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_CORPORATE_BODY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_CORPORATE_BODY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_CORPORATE_BODY));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_NON_PROFIT_ORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_NON_PROFIT_ORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_NON_PROFIT_ORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_NON_PROFIT_ORGANIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_NETWORKING_SUB_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_NETWORKING_SUB_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_NETWORKING_SUB_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_NETWORKING_SUB_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_FIDUCIARIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_FIDUCIARIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_FIDUCIARIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_FIDUCIARIES));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_TRUSTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_TRUSTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_TRUSTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_TRUSTS));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_PENSION_PLAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_PENSION_PLAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_PENSION_PLAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_PENSION_PLAN));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_INDIVIDUAL_TRUSTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_INDIVIDUAL_TRUSTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_INDIVIDUAL_TRUSTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_INDIVIDUAL_TRUSTEE));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_PUBLIC_COMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_PUBLIC_COMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_PUBLIC_COMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_PUBLIC_COMPANY));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_PRIVATE_COMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_PRIVATE_COMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_PRIVATE_COMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_PRIVATE_COMPANY));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_INDIVIDUAL_INVESTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_INDIVIDUAL_INVESTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_INDIVIDUAL_INVESTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_INDIVIDUAL_INVESTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_INSTITUTIONAL_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_INSTITUTIONAL_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_INSTITUTIONAL_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_INSTITUTIONAL_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_COMBINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_COMBINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_COMBINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_COMBINED));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_MEMBER_FIRM_EMPLOYEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_MEMBER_FIRM_EMPLOYEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_MEMBER_FIRM_EMPLOYEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_MEMBER_FIRM_EMPLOYEE));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_MARKET_MAKING_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_MARKET_MAKING_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_MARKET_MAKING_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_MARKET_MAKING_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_PROPRIETARY_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_PROPRIETARY_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_PROPRIETARY_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_PROPRIETARY_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_NONBROKER_DEALER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_NONBROKER_DEALER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_NONBROKER_DEALER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_NONBROKER_DEALER));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_UNKNOWN_BENEFICIAL_OWNER_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_UNKNOWN_BENEFICIAL_OWNER_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_UNKNOWN_BENEFICIAL_OWNER_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_UNKNOWN_BENEFICIAL_OWNER_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_FIRMS_ERROR_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_FIRMS_ERROR_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_FIRMS_ERROR_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_FIRMS_ERROR_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_FIRM_AGENCY_AVERAGE_PRICE_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_FIRM_AGENCY_AVERAGE_PRICE_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_FIRM_AGENCY_AVERAGE_PRICE_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_FIRM_AGENCY_AVERAGE_PRICE_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCapacity_RISKLESS_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCapacity_RISKLESS_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCapacity_RISKLESS_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_RISKLESS_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCapacity_INDIVIDUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCapacity_INDIVIDUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCapacity_INDIVIDUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_INDIVIDUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCapacity_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCapacity_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCapacity_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCapacity_AGENT_FOR_OTHER_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCapacity_AGENT_FOR_OTHER_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCapacity_AGENT_FOR_OTHER_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_AGENT_FOR_OTHER_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCapacity_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCapacity_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCapacity_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_AGENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCapacity_PROPRIETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCapacity_PROPRIETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCapacity_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_PROPRIETARY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCapacity_MIXED_CAPACITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCapacity_MIXED_CAPACITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCapacity_MIXED_CAPACITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_MIXED_CAPACITY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_FOREIGN_ENTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_FOREIGN_ENTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_FOREIGN_ENTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_FOREIGN_ENTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_RISKLESS_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_RISKLESS_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_RISKLESS_ARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_RISKLESS_ARBITRAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_PROGRAM_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_PROGRAM_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_PROGRAM_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_PROGRAM_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_UNDERLYING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_UNDERLYING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_UNDERLYING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_UNDERLYING));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_NON_INDEX_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_NON_INDEX_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_NON_INDEX_ARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_NON_INDEX_ARBITRAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_INDEX_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_INDEX_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_INDEX_ARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_INDEX_ARBITRAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_COMPETING_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_COMPETING_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_COMPETING_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_COMPETING_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_ISSUER_HOLDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ISSUER_HOLDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_ISSUER_HOLDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ISSUER_HOLDING));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_ISSUE_PRICE_STABILIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ISSUE_PRICE_STABILIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_ISSUE_PRICE_STABILIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ISSUE_PRICE_STABILIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_NON_ALGORITHMIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_NON_ALGORITHMIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_NON_ALGORITHMIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_NON_ALGORITHMIC));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_ALGORITHMIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ALGORITHMIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_ALGORITHMIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ALGORITHMIC));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_INSIDER_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_INSIDER_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_INSIDER_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_INSIDER_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_SIGNIFICANT_SHAREHOLDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_SIGNIFICANT_SHAREHOLDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_SIGNIFICANT_SHAREHOLDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_SIGNIFICANT_SHAREHOLDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_NORMAL_COURSE_ISSUER_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_NORMAL_COURSE_ISSUER_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_NORMAL_COURSE_ISSUER_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_NORMAL_COURSE_ISSUER_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ALL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ALL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ALL_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ALL_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_ACFI_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_ACFI_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_ACFI_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_ACFI_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_SECURITY_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_SECURITY_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_REQUEST_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_REQUEST_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_REQUEST_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_REQUEST_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ALL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ALL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ALL_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ALL_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_ACFI_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_ACFI_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_ACFI_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_ACFI_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_CFI_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_CFI_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_CFI_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_CFI_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteType_INDICATIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteType_INDICATIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteType_INDICATIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteType_INDICATIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteType_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteType_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteType_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteType_TRADEABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteType_RESTRICTED_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteType_RESTRICTED_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteType_RESTRICTED_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteType_RESTRICTED_TRADEABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteType_COUNTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteType_COUNTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteType_COUNTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteType_COUNTER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteType_INITIALLY_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteType_INITIALLY_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteType_INITIALLY_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteType_INITIALLY_TRADEABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_CashMargin_MARGIN_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashMargin_MARGIN_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashMargin_MARGIN_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CashMargin_MARGIN_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_CashMargin_MARGIN_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashMargin_MARGIN_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashMargin_MARGIN_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CashMargin_MARGIN_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_CashMargin_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashMargin_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashMargin_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CashMargin_CASH));
  return pyobj;
}


SWIGINTERN int Swig_var_Scope_LOCAL_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Scope_LOCAL_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Scope_LOCAL_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Scope_LOCAL_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_Scope_NATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Scope_NATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Scope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Scope_NATIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_Scope_GLOBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Scope_GLOBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Scope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Scope_GLOBAL));
  return pyobj;
}


SWIGINTERN int Swig_var_MDImplicitDelete_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDImplicitDelete_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDImplicitDelete_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDImplicitDelete_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDImplicitDelete_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDImplicitDelete_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDImplicitDelete_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDImplicitDelete_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CROSS_AON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_AON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CROSS_AON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_AON));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CROSS_IOC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_IOC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CROSS_IOC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_IOC));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CROSS_ONE_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_ONE_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CROSS_ONE_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_ONE_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CROSS_SAME_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_SAME_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CROSS_SAME_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_SAME_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_BASIS_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_BASIS_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_BASIS_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_BASIS_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CONTINGENT_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CONTINGENT_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CONTINGENT_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CONTINGENT_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_VWAP_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_VWAP_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_VWAP_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_VWAP_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_STS_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_STS_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_STS_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_STS_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CUSTOMER_TO_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CUSTOMER_TO_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CUSTOMER_TO_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CUSTOMER_TO_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossPrioritization_SELL_SIDE_IS_PRIORITIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_SELL_SIDE_IS_PRIORITIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossPrioritization_SELL_SIDE_IS_PRIORITIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_SELL_SIDE_IS_PRIORITIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossPrioritization_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossPrioritization_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossPrioritization_BUY_SIDE_IS_PRIORITIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_BUY_SIDE_IS_PRIORITIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossPrioritization_BUY_SIDE_IS_PRIORITIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_BUY_SIDE_IS_PRIORITIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_NoSides_ONE_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NoSides_ONE_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NoSides_ONE_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::NoSides_ONE_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_NoSides_BOTH_SIDES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NoSides_BOTH_SIDES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NoSides_BOTH_SIDES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::NoSides_BOTH_SIDES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListRequestType_SECURITY_TYPE_AND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_SECURITY_TYPE_AND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListRequestType_SECURITY_TYPE_AND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_SECURITY_TYPE_AND));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListRequestType_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListRequestType_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListRequestType_TRADING_SESSION_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_TRADING_SESSION_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListRequestType_TRADING_SESSION_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_TRADING_SESSION_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListRequestType_ALL_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_ALL_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListRequestType_ALL_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_ALL_SECURITIES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListRequestType_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListRequestType_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListRequestType_MARKET_ID_OR_MARKET_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_MARKET_ID_OR_MARKET_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListRequestType_MARKET_ID_OR_MARKET_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_MARKET_ID_OR_MARKET_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestResult_VALID_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_VALID_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestResult_VALID_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_VALID_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestResult_NO_INSTRUMENTS_FOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_NO_INSTRUMENTS_FOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestResult_NO_INSTRUMENTS_FOUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_NO_INSTRUMENTS_FOUND));
  return pyobj;
}


SWIGINTERN int Swig_var_MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_INSTRUMENT_LEGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_INSTRUMENT_LEGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_INSTRUMENT_LEGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_INSTRUMENT_LEGS));
  return pyobj;
}


SWIGINTERN int Swig_var_MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADING_SESSION_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADING_SESSION_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADING_SESSION_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADING_SESSION_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatusRejReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatusRejReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatusRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatusRejReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestType_ALL_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestType_ALL_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestType_ALL_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_ALL_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_PreviouslyReported_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreviouslyReported_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PreviouslyReported_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PreviouslyReported_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_PreviouslyReported_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreviouslyReported_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PreviouslyReported_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PreviouslyReported_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchStatus_COMPARED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_COMPARED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchStatus_COMPARED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MatchStatus_COMPARED));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchStatus_UNCOMPARED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_UNCOMPARED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchStatus_UNCOMPARED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MatchStatus_UNCOMPARED));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchStatus_ADVISORY_OR_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_ADVISORY_OR_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchStatus_ADVISORY_OR_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MatchStatus_ADVISORY_OR_ALERT));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchStatus_MISMATCHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_MISMATCHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchStatus_MISMATCHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MatchStatus_MISMATCHED));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_A5_EXACT_MATCH_SUMMARIZED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_A5_EXACT_MATCH_SUMMARIZED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_A5_EXACT_MATCH_SUMMARIZED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_A5_EXACT_MATCH_SUMMARIZED_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_EXACT_MATCH_MINUS_BADGES_TIMES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACT_MATCH_MINUS_BADGES_TIMES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_EXACT_MATCH_MINUS_BADGES_TIMES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_MINUS_BADGES_TIMES);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ACTM6_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACTM6_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ACTM6_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACTM6_MATCH);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ACT_DEFAULT_AFTER_M2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_DEFAULT_AFTER_M2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ACT_DEFAULT_AFTER_M2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_DEFAULT_AFTER_M2);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ACT_ACCEPTED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_ACCEPTED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ACT_ACCEPTED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_ACCEPTED_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_A2_EXACT_MATCH_SUMMARIZED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_A2_EXACT_MATCH_SUMMARIZED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_A2_EXACT_MATCH_SUMMARIZED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_A2_EXACT_MATCH_SUMMARIZED_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_A3_EXACT_MATCH_SUMMARIZED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_A3_EXACT_MATCH_SUMMARIZED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_A3_EXACT_MATCH_SUMMARIZED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_A3_EXACT_MATCH_SUMMARIZED_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_A4_EXACT_MATCH_SUMMARIZED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_A4_EXACT_MATCH_SUMMARIZED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_A4_EXACT_MATCH_SUMMARIZED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_A4_EXACT_MATCH_SUMMARIZED_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_SUMMARIZED_MATCH_MINUS_BADGES_TIMES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZED_MATCH_MINUS_BADGES_TIMES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_SUMMARIZED_MATCH_MINUS_BADGES_TIMES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_MINUS_BADGES_TIMES);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_EXACT_MATCH_PLUS4_BADGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACT_MATCH_PLUS4_BADGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_EXACT_MATCH_PLUS4_BADGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_PLUS4_BADGES);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_EXACT_MATCH_PLUS2_BADGES_EXEC_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACT_MATCH_PLUS2_BADGES_EXEC_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_EXACT_MATCH_PLUS2_BADGES_EXEC_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_PLUS2_BADGES_EXEC_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_EXACT_MATCH_PLUS2_BADGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACT_MATCH_PLUS2_BADGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_EXACT_MATCH_PLUS2_BADGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_PLUS2_BADGES);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_OCS_LOCKED_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_OCS_LOCKED_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_OCS_LOCKED_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_OCS_LOCKED_IN);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ACT_DEFAULT_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_DEFAULT_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ACT_DEFAULT_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_DEFAULT_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_EXACT_MATCH_PLUS4_BADGES_EXEC_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACT_MATCH_PLUS4_BADGES_EXEC_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_EXACT_MATCH_PLUS4_BADGES_EXEC_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_PLUS4_BADGES_EXEC_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_A1_EXACT_MATCH_SUMMARIZED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_A1_EXACT_MATCH_SUMMARIZED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_A1_EXACT_MATCH_SUMMARIZED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_A1_EXACT_MATCH_SUMMARIZED_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_EXACT_MATCH_PLUS_EXEC_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACT_MATCH_PLUS_EXEC_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_EXACT_MATCH_PLUS_EXEC_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_PLUS_EXEC_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_CONTINUOUS_AUTO_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CONTINUOUS_AUTO_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_CONTINUOUS_AUTO_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CONTINUOUS_AUTO_MATCH);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_CROSS_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CROSS_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_CROSS_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CROSS_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_COUNTER_ORDER_SELECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_COUNTER_ORDER_SELECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_COUNTER_ORDER_SELECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_COUNTER_ORDER_SELECTION);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_CALL_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CALL_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_CALL_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CALL_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ONE_PARTY_TRADE_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ONE_PARTY_TRADE_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ONE_PARTY_TRADE_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ONE_PARTY_TRADE_REPORT);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_TWO_PARTY_TRADE_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_TWO_PARTY_TRADE_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_TWO_PARTY_TRADE_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_TWO_PARTY_TRADE_REPORT);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_CONFIRMED_TRADE_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CONFIRMED_TRADE_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_CONFIRMED_TRADE_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CONFIRMED_TRADE_REPORT);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_AUTO_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_AUTO_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_AUTO_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_AUTO_MATCH);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ISSUING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ISSUING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ISSUING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ISSUING);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_SYSTEMATIC_INTERNALISER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SYSTEMATIC_INTERNALISER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_SYSTEMATIC_INTERNALISER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SYSTEMATIC_INTERNALISER);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_AUTO_MATCH_LAST_LOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_AUTO_MATCH_LAST_LOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_AUTO_MATCH_LAST_LOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_AUTO_MATCH_LAST_LOOK);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_CROSS_AUCTION_LAST_LOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CROSS_AUCTION_LAST_LOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_CROSS_AUCTION_LAST_LOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CROSS_AUCTION_LAST_LOOK);
  return pyobj;
}


SWIGINTERN int Swig_var_OddLot_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OddLot_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OddLot_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OddLot_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_OddLot_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OddLot_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OddLot_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OddLot_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_MANUAL_MODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_MANUAL_MODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_MANUAL_MODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_MANUAL_MODE));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_MULTILATERAL_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_MULTILATERAL_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_MULTILATERAL_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_MULTILATERAL_NETTING));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_AUTOMATIC_POSTING_MODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_AUTOMATIC_POSTING_MODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_AUTOMATIC_POSTING_MODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_AUTOMATIC_POSTING_MODE));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_BILATERAL_NETTING_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_BILATERAL_NETTING_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_BILATERAL_NETTING_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_BILATERAL_NETTING_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_AUTOMATIC_GIVE_UP_MODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_AUTOMATIC_GIVE_UP_MODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_AUTOMATIC_GIVE_UP_MODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_AUTOMATIC_GIVE_UP_MODE));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_SPECIAL_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_SPECIAL_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_SPECIAL_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_SPECIAL_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_EX_CLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_EX_CLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_EX_CLEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EX_CLEARING));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_PROCESS_NORMALLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_PROCESS_NORMALLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_PROCESS_NORMALLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_PROCESS_NORMALLY));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_EXCLUDE_FROM_ALL_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_EXCLUDE_FROM_ALL_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_EXCLUDE_FROM_ALL_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EXCLUDE_FROM_ALL_NETTING));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_CUSTOMER_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_CUSTOMER_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_CUSTOMER_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_CUSTOMER_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_SELF_CLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_SELF_CLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_SELF_CLEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_SELF_CLEARING));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_BUY_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_BUY_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_BUY_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_BUY_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_HOUSE_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_HOUSE_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_HOUSE_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_HOUSE_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_HOUSE_TRADER_CROSS_MARGINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_HOUSE_TRADER_CROSS_MARGINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_HOUSE_TRADER_CROSS_MARGINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_HOUSE_TRADER_CROSS_MARGINED));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_CARRIED_NON_CUSTOMER_SIDE_CROSS_MARGINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_CARRIED_NON_CUSTOMER_SIDE_CROSS_MARGINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_CARRIED_NON_CUSTOMER_SIDE_CROSS_MARGINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_CARRIED_NON_CUSTOMER_SIDE_CROSS_MARGINED));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_FLOOR_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_FLOOR_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_FLOOR_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_FLOOR_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_CARRIED_NON_CUSTOMER_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_CARRIED_NON_CUSTOMER_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_CARRIED_NON_CUSTOMER_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_CARRIED_NON_CUSTOMER_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_CARRIED_CUSTOMER_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_CARRIED_CUSTOMER_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_CARRIED_CUSTOMER_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_CARRIED_CUSTOMER_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_JOINT_BACK_OFFICE_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_JOINT_BACK_OFFICE_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_JOINT_BACK_OFFICE_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_JOINT_BACK_OFFICE_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_EQUITIES_SPECIALIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_EQUITIES_SPECIALIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_EQUITIES_SPECIALIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_EQUITIES_SPECIALIST));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_OPTIONS_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_OPTIONS_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_OPTIONS_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_OPTIONS_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_OPTIONS_FIRM_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_OPTIONS_FIRM_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_OPTIONS_FIRM_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_OPTIONS_FIRM_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_ACCOUNT_CUSTOMER_NON_CUSTOMER_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_ACCOUNT_CUSTOMER_NON_CUSTOMER_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_ACCOUNT_CUSTOMER_NON_CUSTOMER_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNT_CUSTOMER_NON_CUSTOMER_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_ACCOUNT_ORDERS_MULTIPLE_CUSTOMERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_ACCOUNT_ORDERS_MULTIPLE_CUSTOMERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_ACCOUNT_ORDERS_MULTIPLE_CUSTOMERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNT_ORDERS_MULTIPLE_CUSTOMERS));
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderCapacity_ALL_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderCapacity_ALL_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderCapacity_ALL_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_ALL_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderCapacity_RETAIL_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderCapacity_RETAIL_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderCapacity_RETAIL_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_RETAIL_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_ACFI_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ORDERS_FOR_ACFI_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_ACFI_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_ACFI_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTY_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTY_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTY_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTY_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ALL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ALL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ALL_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ALL_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_SECURITY_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_SECURITY_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_DayBookingInst_AUTO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DayBookingInst_AUTO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DayBookingInst_AUTO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_AUTO));
  return pyobj;
}


SWIGINTERN int Swig_var_DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING));
  return pyobj;
}


SWIGINTERN int Swig_var_DayBookingInst_ACCUMULATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DayBookingInst_ACCUMULATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DayBookingInst_ACCUMULATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_ACCUMULATE));
  return pyobj;
}


SWIGINTERN int Swig_var_BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PreallocMethod_PRO_RATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreallocMethod_PRO_RATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PreallocMethod_PRO_RATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PreallocMethod_PRO_RATA));
  return pyobj;
}


SWIGINTERN int Swig_var_PreallocMethod_DO_NOT_PRO_RATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreallocMethod_DO_NOT_PRO_RATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PreallocMethod_DO_NOT_PRO_RATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PreallocMethod_DO_NOT_PRO_RATA));
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_PRE_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_PRE_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_PRE_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_PRE_TRADING);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_OPENING_OR_OPENING_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_OPENING_OR_OPENING_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_OPENING_OR_OPENING_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_OPENING_OR_OPENING_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_CONTINUOUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_CONTINUOUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_CONTINUOUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_CONTINUOUS);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_POST_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_POST_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_POST_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_POST_TRADING);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_INTRADAY_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_INTRADAY_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_INTRADAY_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_INTRADAY_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_QUIESCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_QUIESCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_QUIESCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_QUIESCENT);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_SCHEDULED_INTRADAY_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_SCHEDULED_INTRADAY_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_SCHEDULED_INTRADAY_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_SCHEDULED_INTRADAY_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_ANY_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_ANY_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_ANY_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_ANY_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_UNSCHEDULED_INTRADAY_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_UNSCHEDULED_INTRADAY_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_UNSCHEDULED_INTRADAY_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_UNSCHEDULED_INTRADAY_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_OUT_OF_MAIN_SESSION_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_OUT_OF_MAIN_SESSION_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_OUT_OF_MAIN_SESSION_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_OUT_OF_MAIN_SESSION_TRADING);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_PRIVATE_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_PRIVATE_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_PRIVATE_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_PRIVATE_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_PUBLIC_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_PUBLIC_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_PUBLIC_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_PUBLIC_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_GROUP_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_GROUP_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_GROUP_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_GROUP_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_BUYSIDE_READY_TO_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_READY_TO_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_READY_TO_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_READY_TO_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_READY_TO_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_READY_TO_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_CALCULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_CALCULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_CALCULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_CALCULATED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_WAREHOUSE_INSTRUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_WAREHOUSE_INSTRUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_WAREHOUSE_INSTRUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_WAREHOUSE_INSTRUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_REQUEST_TO_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_REQUEST_TO_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_REQUEST_TO_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_REQUEST_TO_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_ACCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_ACCEPT_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_ACCEPT_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_ACCEPT_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_ACCEPT_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_INCOMPLETE_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_INCOMPLETE_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_INCOMPLETE_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_INCOMPLETE_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_COMPLETE_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_COMPLETE_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_COMPLETE_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_COMPLETE_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_REVERSAL_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_REVERSAL_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_REVERSAL_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_REVERSAL_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_REOPEN_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_REOPEN_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_REOPEN_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_REOPEN_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_CANCEL_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_CANCEL_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_CANCEL_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_CANCEL_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_GIVEUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_GIVEUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_GIVEUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_GIVEUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_TAKEUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_TAKEUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_TAKEUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_TAKEUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_REFUSE_TAKEUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_REFUSE_TAKEUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_REFUSE_TAKEUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_REFUSE_TAKEUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_INITIATE_REVERSAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_INITIATE_REVERSAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_INITIATE_REVERSAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_INITIATE_REVERSAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_REVERSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_REVERSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_REVERSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_REVERSE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_REFUSE_REVERSAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_REFUSE_REVERSAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_REFUSE_REVERSAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_REFUSE_REVERSAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_SUB_ALLOCATION_GIVEUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_SUB_ALLOCATION_GIVEUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_SUB_ALLOCATION_GIVEUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_SUB_ALLOCATION_GIVEUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_APPROVE_GIVEUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_APPROVE_GIVEUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_APPROVE_GIVEUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_APPROVE_GIVEUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_APPROVE_TAKEUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_APPROVE_TAKEUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_APPROVE_TAKEUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_APPROVE_TAKEUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_NOTIONAL_VALUE_AVERAGE_PX_GROUP_ALLOC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_NOTIONAL_VALUE_AVERAGE_PX_GROUP_ALLOC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_NOTIONAL_VALUE_AVERAGE_PX_GROUP_ALLOC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_NOTIONAL_VALUE_AVERAGE_PX_GROUP_ALLOC));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_FIRMS106_H_AND106_J_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_FIRMS106_H_AND106_J is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_FIRMS106_H_AND106_J_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_FIRMS106_H_AND106_J);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_FIFTH_YEAR_DELEGATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_FIFTH_YEAR_DELEGATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_FIFTH_YEAR_DELEGATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_FIFTH_YEAR_DELEGATE);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_FOURTH_YEAR_DELEGATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_FOURTH_YEAR_DELEGATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_FOURTH_YEAR_DELEGATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_FOURTH_YEAR_DELEGATE);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_THIRD_YEAR_DELEGATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_THIRD_YEAR_DELEGATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_THIRD_YEAR_DELEGATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_THIRD_YEAR_DELEGATE);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_SECOND_YEAR_DELEGATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_SECOND_YEAR_DELEGATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_SECOND_YEAR_DELEGATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_SECOND_YEAR_DELEGATE);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_FIRST_YEAR_DELEGATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_FIRST_YEAR_DELEGATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_FIRST_YEAR_DELEGATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_FIRST_YEAR_DELEGATE);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_GIM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_GIM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_GIM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_GIM);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_SIXTH_YEAR_DELEGATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_SIXTH_YEAR_DELEGATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_SIXTH_YEAR_DELEGATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_SIXTH_YEAR_DELEGATE);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_CBOE_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_CBOE_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_CBOE_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_CBOE_MEMBER);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_LESSEE106_F_EMPLOYEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_LESSEE106_F_EMPLOYEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_LESSEE106_F_EMPLOYEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_LESSEE106_F_EMPLOYEES);
  return pyobj;
}


SWIGINTERN int Swig_var_WorkingIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable WorkingIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_WorkingIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::WorkingIndicator_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_WorkingIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable WorkingIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_WorkingIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::WorkingIndicator_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_PriorityIndicator_PRIORITY_UNCHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriorityIndicator_PRIORITY_UNCHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriorityIndicator_PRIORITY_UNCHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriorityIndicator_PRIORITY_UNCHANGED));
  return pyobj;
}


SWIGINTERN int Swig_var_PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_LegalConfirm_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegalConfirm_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LegalConfirm_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LegalConfirm_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_LegalConfirm_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegalConfirm_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LegalConfirm_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LegalConfirm_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_TOO_LATE_TO_ENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_TOO_LATE_TO_ENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_TOO_LATE_TO_ENTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_TOO_LATE_TO_ENTER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_INVALID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_INVALID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_INVALID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_INVALID_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_NO_INVENTORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NO_INVENTORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_NO_INVENTORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NO_INVENTORY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_PASS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_PASS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_PASS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_PASS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_INSUFFICIENT_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_INSUFFICIENT_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_INSUFFICIENT_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_INSUFFICIENT_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_EXCEEDED_CLIP_SIZE_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_EXCEEDED_CLIP_SIZE_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_EXCEEDED_CLIP_SIZE_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_EXCEEDED_CLIP_SIZE_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_EXCEEDED_DV01_PV01_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_EXCEEDED_DV01_PV01_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_EXCEEDED_DV01_PV01_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_EXCEEDED_DV01_PV01_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_EXCEEDED_CS01_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_EXCEEDED_CS01_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_EXCEEDED_CS01_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_EXCEEDED_CS01_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_REGULAR);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_CASH);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_NEXT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_NEXT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_NEXT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_NEXT_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_T_PLUS2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T_PLUS2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_T_PLUS2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T_PLUS2);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_T_PLUS3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T_PLUS3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_T_PLUS3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T_PLUS3);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_T_PLUS4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T_PLUS4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_T_PLUS4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T_PLUS4);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_FUTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_FUTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_FUTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_FUTURE);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_WHEN_AND_IF_ISSUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_WHEN_AND_IF_ISSUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_WHEN_AND_IF_ISSUED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_WHEN_AND_IF_ISSUED);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_SELLERS_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_SELLERS_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_SELLERS_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_SELLERS_OPTION);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_T_PLUS5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T_PLUS5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_T_PLUS5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T_PLUS5);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_BROKEN_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_BROKEN_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_BROKEN_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_BROKEN_DATE);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_FX_SPOT_NEXT_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_FX_SPOT_NEXT_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_FX_SPOT_NEXT_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_FX_SPOT_NEXT_SETTLEMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettlFlag_DAILY_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_DAILY_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettlFlag_DAILY_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_DAILY_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettlFlag_SESSION_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_SESSION_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettlFlag_SESSION_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_SESSION_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettlFlag_EXPECTED_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_EXPECTED_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettlFlag_EXPECTED_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_EXPECTED_ENTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_BidTradeType_RISK_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidTradeType_RISK_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidTradeType_RISK_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_RISK_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_BidTradeType_VWAP_GUARANTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidTradeType_VWAP_GUARANTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidTradeType_VWAP_GUARANTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_VWAP_GUARANTEE));
  return pyobj;
}


SWIGINTERN int Swig_var_BidTradeType_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidTradeType_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidTradeType_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_AGENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_BidTradeType_GUARANTEED_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidTradeType_GUARANTEED_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidTradeType_GUARANTEED_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_GUARANTEED_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_AcctIDSource_BIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AcctIDSource_BIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AcctIDSource_BIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_BIC));
  return pyobj;
}


SWIGINTERN int Swig_var_AcctIDSource_SID_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AcctIDSource_SID_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AcctIDSource_SID_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_SID_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_AcctIDSource_TFM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AcctIDSource_TFM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AcctIDSource_TFM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_TFM));
  return pyobj;
}


SWIGINTERN int Swig_var_AcctIDSource_OMGEO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AcctIDSource_OMGEO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AcctIDSource_OMGEO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_OMGEO));
  return pyobj;
}


SWIGINTERN int Swig_var_AcctIDSource_DTCC_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AcctIDSource_DTCC_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AcctIDSource_DTCC_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_DTCC_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_AcctIDSource_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AcctIDSource_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AcctIDSource_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_AcctIDSource_SPSAID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AcctIDSource_SPSAID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AcctIDSource_SPSAID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_SPSAID));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmStatus_MISMATCHED_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_MISMATCHED_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmStatus_MISMATCHED_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_MISMATCHED_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmStatus_CONFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_CONFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmStatus_CONFIRMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_CONFIRMED));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmStatus_REQUEST_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_REQUEST_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmStatus_REQUEST_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_REQUEST_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryForm_BOOK_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryForm_BOOK_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryForm_BOOK_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryForm_BOOK_ENTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryForm_BEARER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryForm_BEARER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryForm_BEARER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryForm_BEARER));
  return pyobj;
}


SWIGINTERN int Swig_var_LegSwapType_PAR_FOR_PAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegSwapType_PAR_FOR_PAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LegSwapType_PAR_FOR_PAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LegSwapType_PAR_FOR_PAR));
  return pyobj;
}


SWIGINTERN int Swig_var_LegSwapType_MODIFIED_DURATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegSwapType_MODIFIED_DURATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LegSwapType_MODIFIED_DURATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LegSwapType_MODIFIED_DURATION));
  return pyobj;
}


SWIGINTERN int Swig_var_LegSwapType_RISK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegSwapType_RISK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LegSwapType_RISK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LegSwapType_RISK));
  return pyobj;
}


SWIGINTERN int Swig_var_LegSwapType_PROCEEDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegSwapType_PROCEEDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LegSwapType_PROCEEDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LegSwapType_PROCEEDS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PER_SHARE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PER_SHARE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PER_SHARE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PER_SHARE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_FIXED_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_FIXED_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_FIXED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_FIXED_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_DISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_DISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_DISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_DISCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PREMIUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PREMIUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PREMIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PREMIUM));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_TED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_TED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_TED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_TED_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_TED_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_TED_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_TED_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_TED_YIELD));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_YIELD_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_YIELD_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_YIELD_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_YIELD_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_YIELD));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PRICE_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PRICE_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PRICE_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PRICE_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PRODUCT_TICKS_IN_HALVES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PRODUCT_TICKS_IN_HALVES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PRODUCT_TICKS_IN_HALVES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PRODUCT_TICKS_IN_HALVES));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PRODUCT_TICKS_IN_FOURTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PRODUCT_TICKS_IN_FOURTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PRODUCT_TICKS_IN_FOURTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PRODUCT_TICKS_IN_FOURTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PRODUCT_TICKS_IN_EIGHTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PRODUCT_TICKS_IN_EIGHTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PRODUCT_TICKS_IN_EIGHTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PRODUCT_TICKS_IN_EIGHTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PRODUCT_TICKS_IN_SIXTEENTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PRODUCT_TICKS_IN_SIXTEENTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PRODUCT_TICKS_IN_SIXTEENTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PRODUCT_TICKS_IN_SIXTEENTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PRODUCT_TICKS_IN_SIXTY_FOURTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PRODUCT_TICKS_IN_SIXTY_FOURTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PRODUCT_TICKS_IN_SIXTY_FOURTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PRODUCT_TICKS_IN_SIXTY_FOURTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_NORMAL_RATE_REPRESENTATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_NORMAL_RATE_REPRESENTATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_NORMAL_RATE_REPRESENTATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_NORMAL_RATE_REPRESENTATION));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_INVERSE_RATE_REPRESENTATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_INVERSE_RATE_REPRESENTATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_INVERSE_RATE_REPRESENTATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_INVERSE_RATE_REPRESENTATION));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_BASIS_POINTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_BASIS_POINTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_BASIS_POINTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_BASIS_POINTS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_UP_FRONT_POINTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_UP_FRONT_POINTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_UP_FRONT_POINTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_UP_FRONT_POINTS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_INTEREST_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_INTEREST_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_INTEREST_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_INTEREST_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PERCENTAGE_OF_NOTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PERCENTAGE_OF_NOTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PERCENTAGE_OF_NOTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PERCENTAGE_OF_NOTIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_HIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_HIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_HIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_HIT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_COUNTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_COUNTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_COUNTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_COUNTER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_COVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_COVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_COVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_COVER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_DONE_AWAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_DONE_AWAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_DONE_AWAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_DONE_AWAY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_PASS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_PASS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_PASS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_PASS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_END_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_END_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_END_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_END_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_TIMED_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_TIMED_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_TIMED_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_TIMED_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_TIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_TIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_TIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_TIED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_TIED_COVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_TIED_COVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_TIED_COVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_TIED_COVER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_ACCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_TERMINATE_CONTRACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_TERMINATE_CONTRACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_TERMINATE_CONTRACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_TERMINATE_CONTRACT));
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_TRANSACTION_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSACTION_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_TRANSACTION_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_INTRA_SPREAD_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_INTRA_SPREAD_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_INTRA_SPREAD_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_INTRA_SPREAD_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_INTER_SPREAD_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_INTER_SPREAD_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_INTER_SPREAD_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_INTER_SPREAD_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_END_OF_DAY_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_END_OF_DAY_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_END_OF_DAY_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_END_OF_DAY_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_START_OF_DAY_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_START_OF_DAY_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_START_OF_DAY_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_START_OF_DAY_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_OPTION_EXERCISE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_OPTION_EXERCISE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_OPTION_EXERCISE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_OPTION_EXERCISE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_OPTION_ASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_OPTION_ASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_OPTION_ASSIGNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_OPTION_ASSIGNMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_TRANSACTION_FROM_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSACTION_FROM_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_TRANSACTION_FROM_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_FROM_EXERCISE);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_TRANSACTION_FROM_ASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSACTION_FROM_ASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_TRANSACTION_FROM_ASSIGNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_FROM_ASSIGNMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_PIT_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_PIT_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_PIT_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_PIT_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_TRANSFER_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSFER_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_TRANSFER_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSFER_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_ELECTRONIC_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_ELECTRONIC_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_ELECTRONIC_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_ELECTRONIC_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_ALLOCATION_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_ALLOCATION_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_ALLOCATION_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_ALLOCATION_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_ADJUSTMENT_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_ADJUSTMENT_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_ADJUSTMENT_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_ADJUSTMENT_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_AS_OF_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_AS_OF_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_AS_OF_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_AS_OF_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_DELIVERY_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_DELIVERY_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_DELIVERY_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_DELIVERY_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_TOTAL_TRANSACTION_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TOTAL_TRANSACTION_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_TOTAL_TRANSACTION_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TOTAL_TRANSACTION_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_CROSS_MARGIN_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_CROSS_MARGIN_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_CROSS_MARGIN_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_CROSS_MARGIN_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_INTEGRAL_SPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_INTEGRAL_SPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_INTEGRAL_SPLIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_INTEGRAL_SPLIT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_RECEIVE_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_RECEIVE_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_RECEIVE_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_RECEIVE_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_CORPORATE_ACTION_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_CORPORATE_ACTION_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_CORPORATE_ACTION_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_CORPORATE_ACTION_ADJUSTMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_DELIVERY_NOTICE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_DELIVERY_NOTICE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_DELIVERY_NOTICE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_DELIVERY_NOTICE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_EXCHANGE_FOR_PHYSICAL_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_EXCHANGE_FOR_PHYSICAL_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_EXCHANGE_FOR_PHYSICAL_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_EXCHANGE_FOR_PHYSICAL_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_PRIVATELY_NEGOTIATED_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_PRIVATELY_NEGOTIATED_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_NET_DELTA_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_NET_DELTA_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_NET_DELTA_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_NET_DELTA_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_CREDIT_EVENT_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_CREDIT_EVENT_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_CREDIT_EVENT_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_CREDIT_EVENT_ADJUSTMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_SUCCESSION_EVENT_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_SUCCESSION_EVENT_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_SUCCESSION_EVENT_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_SUCCESSION_EVENT_ADJUSTMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_NET_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_NET_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_NET_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_NET_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_GROSS_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_GROSS_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_GROSS_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_GROSS_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_INTRADAY_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_INTRADAY_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_INTRADAY_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_INTRADAY_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_GROSS_LONG_NON_DELTA_ADJUSTED_SWAPTION_POSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_GROSS_LONG_NON_DELTA_ADJUSTED_SWAPTION_POSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_GROSS_LONG_NON_DELTA_ADJUSTED_SWAPTION_POSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_GROSS_LONG_NON_DELTA_ADJUSTED_SWAPTION_POSITION);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_LONG_DELTA_ADJUSTED_PAIRED_SWAPTION_POSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_LONG_DELTA_ADJUSTED_PAIRED_SWAPTION_POSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_LONG_DELTA_ADJUSTED_PAIRED_SWAPTION_POSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_LONG_DELTA_ADJUSTED_PAIRED_SWAPTION_POSITION);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_EXPIRING_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_EXPIRING_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_EXPIRING_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_EXPIRING_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_QUANTITY_NOT_EXERCISED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_QUANTITY_NOT_EXERCISED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_QUANTITY_NOT_EXERCISED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_QUANTITY_NOT_EXERCISED);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_REQUESTED_EXERCISE_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_REQUESTED_EXERCISE_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_REQUESTED_EXERCISE_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_REQUESTED_EXERCISE_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_CASH_FUTURES_EQUIVALENT_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_CASH_FUTURES_EQUIVALENT_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_CASH_FUTURES_EQUIVALENT_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_CASH_FUTURES_EQUIVALENT_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_LOAN_OR_BORROWED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_LOAN_OR_BORROWED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_LOAN_OR_BORROWED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_LOAN_OR_BORROWED_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosQtyStatus_SUBMITTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosQtyStatus_SUBMITTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosQtyStatus_SUBMITTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_SUBMITTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosQtyStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosQtyStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosQtyStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosQtyStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosQtyStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosQtyStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_TRADE_VARIATION_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_TRADE_VARIATION_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_TRADE_VARIATION_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_TRADE_VARIATION_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_PREMIUM_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_PREMIUM_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_PREMIUM_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_PREMIUM_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_CASH_RESIDUAL_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_CASH_RESIDUAL_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_CASH_RESIDUAL_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_CASH_RESIDUAL_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_CASH_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_CASH_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_CASH_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_CASH_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_VALUE_ADJUSTED_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_VALUE_ADJUSTED_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_VALUE_ADJUSTED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_VALUE_ADJUSTED_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_SETTLEMENT_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_SETTLEMENT_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_SETTLEMENT_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_SETTLEMENT_VALUE);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_INITIAL_TRADE_COUPON_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_INITIAL_TRADE_COUPON_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_ACCRUED_COUPON_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_ACCRUED_COUPON_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_ACCRUED_COUPON_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_ACCRUED_COUPON_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_COUPON_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_COUPON_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_COUPON_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_COUPON_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_INCREMENTAL_ACCRUED_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_INCREMENTAL_ACCRUED_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_INCREMENTAL_ACCRUED_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_INCREMENTAL_ACCRUED_COUPON);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_COLLATERALIZED_MARK_TO_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_COLLATERALIZED_MARK_TO_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_COLLATERALIZED_MARK_TO_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_COLLATERALIZED_MARK_TO_MARKET);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_COMPENSATION_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_COMPENSATION_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_COMPENSATION_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_COMPENSATION_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_TOTAL_BANKED_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_TOTAL_BANKED_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_TOTAL_BANKED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_TOTAL_BANKED_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_TOTAL_COLLATERALIZED_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_TOTAL_COLLATERALIZED_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_LONG_PAIRED_SWAP_NOTIONAL_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_LONG_PAIRED_SWAP_NOTIONAL_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_LONG_PAIRED_SWAP_NOTIONAL_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_LONG_PAIRED_SWAP_NOTIONAL_VALUE);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_SHORT_PAIRED_SWAP_NOTIONAL_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_SHORT_PAIRED_SWAP_NOTIONAL_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_SHORT_PAIRED_SWAP_NOTIONAL_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_SHORT_PAIRED_SWAP_NOTIONAL_VALUE);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_START_OF_DAY_ACCRUED_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_START_OF_DAY_ACCRUED_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_START_OF_DAY_ACCRUED_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_START_OF_DAY_ACCRUED_COUPON);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_NET_PRESENT_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_NET_PRESENT_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_NET_PRESENT_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_NET_PRESENT_VALUE);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_START_OF_DAY_NET_PRESENT_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_START_OF_DAY_NET_PRESENT_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_START_OF_DAY_NET_PRESENT_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_START_OF_DAY_NET_PRESENT_VALUE);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_NET_CASH_FLOW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_NET_CASH_FLOW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_NET_CASH_FLOW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_NET_CASH_FLOW);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_PRESENT_VALUE_OF_FEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_PRESENT_VALUE_OF_FEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_PRESENT_VALUE_OF_FEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_PRESENT_VALUE_OF_FEES);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_PRESENT_VALUE_ONE_BASIS_POINTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_PRESENT_VALUE_ONE_BASIS_POINTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_PRESENT_VALUE_ONE_BASIS_POINTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_PRESENT_VALUE_ONE_BASIS_POINTS);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_FIVE_YEAR_EQUIVALENT_NOTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_FIVE_YEAR_EQUIVALENT_NOTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_FIVE_YEAR_EQUIVALENT_NOTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_FIVE_YEAR_EQUIVALENT_NOTIONAL);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_UNDISCOUNTED_MARK_TO_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_UNDISCOUNTED_MARK_TO_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_UNDISCOUNTED_MARK_TO_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_UNDISCOUNTED_MARK_TO_MARKET);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_MARK_TO_MODEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_MARK_TO_MODEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_MARK_TO_MODEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_MARK_TO_MODEL);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_MARK_TO_MARKET_VARIANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_MARK_TO_MARKET_VARIANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_MARK_TO_MARKET_VARIANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_MARK_TO_MARKET_VARIANCE);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_MARK_TO_MODEL_VARIANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_MARK_TO_MODEL_VARIANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_MARK_TO_MODEL_VARIANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_MARK_TO_MODEL_VARIANCE);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_UPFRONT_PAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_UPFRONT_PAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_UPFRONT_PAYMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_UPFRONT_PAYMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_END_VALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_END_VALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_END_VALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_END_VALE);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_OUTSTANDING_MARGIN_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_OUTSTANDING_MARGIN_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_OUTSTANDING_MARGIN_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_OUTSTANDING_MARGIN_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_LOAN_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_LOAN_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_LOAN_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_LOAN_VALUE);
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_DO_NOT_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_DO_NOT_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_DO_NOT_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_DO_NOT_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_POSITION_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_POSITION_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_POSITION_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_POSITION_ADJUSTMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_POSITION_CHANGE_SUBMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_POSITION_CHANGE_SUBMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_POSITION_CHANGE_SUBMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_POSITION_CHANGE_SUBMISSION));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_PLEDGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_PLEDGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_PLEDGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_PLEDGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_LARGE_TRADER_SUBMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_LARGE_TRADER_SUBMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_LARGE_TRADER_SUBMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_LARGE_TRADER_SUBMISSION));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_LARGE_POSITIONS_REPORTING_SUBMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_LARGE_POSITIONS_REPORTING_SUBMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_LARGE_POSITIONS_REPORTING_SUBMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_LARGE_POSITIONS_REPORTING_SUBMISSION));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_LONG_HOLDINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_LONG_HOLDINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_LONG_HOLDINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_LONG_HOLDINGS));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_INTERNAL_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_INTERNAL_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_INTERNAL_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_INTERNAL_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_TRANSFER_OF_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_TRANSFER_OF_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_TRANSFER_OF_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_TRANSFER_OF_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_EXTERNAL_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_EXTERNAL_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_EXTERNAL_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_EXTERNAL_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_CORPORATE_ACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_CORPORATE_ACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_CORPORATE_ACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_CORPORATE_ACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_NOTIFICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_NOTIFICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_NOTIFICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_NOTIFICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_POSITION_CREATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_POSITION_CREATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_POSITION_CREATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_POSITION_CREATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_CLOSEOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_CLOSEOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_CLOSEOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_CLOSEOUT));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_REOPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_REOPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_REOPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_REOPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintAction_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintAction_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintAction_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintAction_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintAction_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintAction_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintAction_REVERSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_REVERSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintAction_REVERSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_REVERSE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSessID_INTRADAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSessID_INTRADAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSessID_INTRADAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlSessID_INTRADAY);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSessID_REGULAR_TRADING_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSessID_REGULAR_TRADING_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSessID_REGULAR_TRADING_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlSessID_REGULAR_TRADING_HOURS);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSessID_ELECTRONIC_TRADING_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSessID_ELECTRONIC_TRADING_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSessID_ELECTRONIC_TRADING_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlSessID_ELECTRONIC_TRADING_HOURS);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSessID_END_OF_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSessID_END_OF_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSessID_END_OF_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlSessID_END_OF_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION));
  return pyobj;
}


SWIGINTERN int Swig_var_AdjustmentType_DELTA_PLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_DELTA_PLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdjustmentType_DELTA_PLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_DELTA_PLUS));
  return pyobj;
}


SWIGINTERN int Swig_var_AdjustmentType_DELTA_MINUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_DELTA_MINUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdjustmentType_DELTA_MINUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_DELTA_MINUS));
  return pyobj;
}


SWIGINTERN int Swig_var_AdjustmentType_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdjustmentType_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_FINAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AdjustmentType_CUSTOMER_SPECIFIC_POSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_CUSTOMER_SPECIFIC_POSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdjustmentType_CUSTOMER_SPECIFIC_POSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_CUSTOMER_SPECIFIC_POSITION));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintStatus_ACCEPTED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_ACCEPTED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintStatus_ACCEPTED_WITH_WARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_ACCEPTED_WITH_WARNINGS));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintStatus_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintStatus_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_COMPLETED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintStatus_COMPLETED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_COMPLETED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintStatus_COMPLETED_WITH_WARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_COMPLETED_WITH_WARNINGS));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintResult_SUCCESSFUL_COMPLETION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintResult_SUCCESSFUL_COMPLETION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintResult_SUCCESSFUL_COMPLETION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_SUCCESSFUL_COMPLETION));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintResult_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintResult_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintResult_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_EXERCISES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_EXERCISES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_EXERCISES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_EXERCISES));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_ASSIGNMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_ASSIGNMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_ASSIGNMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_ASSIGNMENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_SETTLEMENT_ACTIVITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_SETTLEMENT_ACTIVITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_SETTLEMENT_ACTIVITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_SETTLEMENT_ACTIVITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_BACKOUT_MESSAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_BACKOUT_MESSAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_BACKOUT_MESSAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_BACKOUT_MESSAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_DELTA_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_DELTA_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_DELTA_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_DELTA_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_NET_POSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_NET_POSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_NET_POSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_NET_POSITION));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_LARGE_POSITIONS_REPORTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_LARGE_POSITIONS_REPORTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_LARGE_POSITIONS_REPORTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_LARGE_POSITIONS_REPORTING));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_EXERCISE_POSITION_REPORTING_SUBMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_EXERCISE_POSITION_REPORTING_SUBMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_EXERCISE_POSITION_REPORTING_SUBMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_EXERCISE_POSITION_REPORTING_SUBMISSION));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_POSITION_LIMIT_REPORTING_SUBMISSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_POSITION_LIMIT_REPORTING_SUBMISSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_POSITION_LIMIT_REPORTING_SUBMISSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_POSITION_LIMIT_REPORTING_SUBMISSING));
  return pyobj;
}


SWIGINTERN int Swig_var_ResponseTransportType_INBAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResponseTransportType_INBAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ResponseTransportType_INBAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ResponseTransportType_INBAND));
  return pyobj;
}


SWIGINTERN int Swig_var_ResponseTransportType_OUT_OF_BAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResponseTransportType_OUT_OF_BAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ResponseTransportType_OUT_OF_BAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ResponseTransportType_OUT_OF_BAND));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqResult_VALID_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_VALID_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqResult_VALID_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_VALID_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqStatus_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqStatus_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqStatus_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_COMPLETED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqStatus_COMPLETED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqStatus_COMPLETED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqStatus_COMPLETED_WITH_WARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_COMPLETED_WITH_WARNINGS));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlPriceType_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlPriceType_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlPriceType_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlPriceType_FINAL));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlPriceType_THEORETICAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlPriceType_THEORETICAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlPriceType_THEORETICAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlPriceType_THEORETICAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AssignmentMethod_RANDOM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssignmentMethod_RANDOM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssignmentMethod_RANDOM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AssignmentMethod_RANDOM));
  return pyobj;
}


SWIGINTERN int Swig_var_AssignmentMethod_PRO_RATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssignmentMethod_PRO_RATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssignmentMethod_PRO_RATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AssignmentMethod_PRO_RATA));
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseMethod_AUTOMATIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseMethod_AUTOMATIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseMethod_AUTOMATIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExerciseMethod_AUTOMATIC));
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseMethod_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseMethod_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseMethod_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExerciseMethod_MANUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_INVALID_PARTIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALID_PARTIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_INVALID_PARTIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_PARTIES));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_INVALID_DESTINATION_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALID_DESTINATION_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_INVALID_DESTINATION_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_DESTINATION_REQUESTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_TRADE_REQUEST_TYPE_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_TRADE_REQUEST_TYPE_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_TRADE_REQUEST_TYPE_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_TRADE_REQUEST_TYPE_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_NOT_AUTHORIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_NOT_AUTHORIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_NOT_AUTHORIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_NOT_AUTHORIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestStatus_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestStatus_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestStatus_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_COMPLETED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_INVALID_PARTY_ONFORMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_INVALID_PARTY_ONFORMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_INVALID_PARTY_ONFORMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_INVALID_PARTY_ONFORMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_UNKNOWN_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_UNKNOWN_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_UNKNOWN_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_UNKNOWN_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_INVALID_TRADE_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_INVALID_TRADE_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_INVALID_TRADE_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_INVALID_TRADE_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_INVALID_PARTY_INFORMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_INVALID_PARTY_INFORMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_INVALID_PARTY_INFORMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_INVALID_PARTY_INFORMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_REFERENCE_PRICE_NOT_AVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_REFERENCE_PRICE_NOT_AVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_REFERENCE_PRICE_NOT_AVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_REFERENCE_PRICE_NOT_AVAILABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD));
  return pyobj;
}


SWIGINTERN int Swig_var_SideMultiLegReportingType_SINGLE_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideMultiLegReportingType_SINGLE_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideMultiLegReportingType_SINGLE_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_SINGLE_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_SideMultiLegReportingType_MULTILEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideMultiLegReportingType_MULTILEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideMultiLegReportingType_MULTILEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_MULTILEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_EXECUTION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_EXECUTION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_EXECUTION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_EXECUTION_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_TIME_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_TIME_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_TIME_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIME_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_TIME_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_TIME_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_TIME_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIME_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_BROKER_RECEIPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_BROKER_RECEIPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_BROKER_RECEIPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_BROKER_RECEIPT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_BROKER_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_BROKER_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_BROKER_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_BROKER_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_DESK_RECEIPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_DESK_RECEIPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_DESK_RECEIPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_DESK_RECEIPT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_SUBMISSION_TO_CLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_SUBMISSION_TO_CLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_SUBMISSION_TO_CLEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_SUBMISSION_TO_CLEARING));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_TIME_PRIORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_TIME_PRIORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_TIME_PRIORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIME_PRIORITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_ORDERBOOK_ENTRY_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_ORDERBOOK_ENTRY_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_ORDERBOOK_ENTRY_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_ORDERBOOK_ENTRY_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_ORDER_SUBMISSION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_ORDER_SUBMISSION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_ORDER_SUBMISSION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_ORDER_SUBMISSION_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_PUBLICLY_REPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_PUBLICLY_REPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_PUBLICLY_REPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_PUBLICLY_REPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_PUBLIC_REPORT_UPDATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_PUBLIC_REPORT_UPDATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_PUBLIC_REPORT_UPDATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_PUBLIC_REPORT_UPDATED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_NON_PUBLICLY_REPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_NON_PUBLICLY_REPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_NON_PUBLICLY_REPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_NON_PUBLICLY_REPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_NON_PUBLIC_REPORT_UPDATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_NON_PUBLIC_REPORT_UPDATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_NON_PUBLIC_REPORT_UPDATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_NON_PUBLIC_REPORT_UPDATED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_SUBMITTED_FOR_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_SUBMITTED_FOR_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_SUBMITTED_FOR_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_SUBMITTED_FOR_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_UPDATED_FOR_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_UPDATED_FOR_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_UPDATED_FOR_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_UPDATED_FOR_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_CONFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_CONFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_CONFIRMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_CONFIRMED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_UPDATED_FOR_CLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_UPDATED_FOR_CLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_UPDATED_FOR_CLEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_UPDATED_FOR_CLEARING));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_CLEARED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_CLEARED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_CLEARED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_CLEARED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_ALLOCATIONS_SUBMITTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_ALLOCATIONS_SUBMITTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_ALLOCATIONS_SUBMITTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_ALLOCATIONS_SUBMITTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_ALLOCATIONS_UPDATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_ALLOCATIONS_UPDATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_ALLOCATIONS_UPDATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_ALLOCATIONS_UPDATED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_ALLOCATIONS_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_ALLOCATIONS_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_ALLOCATIONS_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_ALLOCATIONS_COMPLETED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_SUBMITTED_TO_REPOSITORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_SUBMITTED_TO_REPOSITORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_SUBMITTED_TO_REPOSITORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_SUBMITTED_TO_REPOSITORY));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_POST_TRD_CONTNTN_EVNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_POST_TRD_CONTNTN_EVNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_POST_TRD_CONTNTN_EVNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_POST_TRD_CONTNTN_EVNT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_POST_TRADE_VALUATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_POST_TRADE_VALUATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_POST_TRADE_VALUATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_POST_TRADE_VALUATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_PREVIOUS_TIME_PRIORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_PREVIOUS_TIME_PRIORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_PREVIOUS_TIME_PRIORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_PREVIOUS_TIME_PRIORITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_IDENTIFIER_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_IDENTIFIER_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_IDENTIFIER_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_IDENTIFIER_ASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_PREVIOUS_IDENTIFIER_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_PREVIOUS_IDENTIFIER_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_PREVIOUS_IDENTIFIER_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_PREVIOUS_IDENTIFIER_ASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_ORDER_CANCELLATION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_ORDER_CANCELLATION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_ORDER_CANCELLATION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_ORDER_CANCELLATION_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_ORDER_MODIFICATION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_ORDER_MODIFICATION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_ORDER_MODIFICATION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_ORDER_MODIFICATION_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_ORDER_ROUTING_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_ORDER_ROUTING_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_ORDER_ROUTING_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_ORDER_ROUTING_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_TRADE_CANCELLATION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_TRADE_CANCELLATION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_TRADE_CANCELLATION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TRADE_CANCELLATION_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_TRADE_MODIFICATION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_TRADE_MODIFICATION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_TRADE_MODIFICATION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TRADE_MODIFICATION_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_REFERENCE_TIME_FOR_NBBO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_REFERENCE_TIME_FOR_NBBO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_REFERENCE_TIME_FOR_NBBO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_REFERENCE_TIME_FOR_NBBO));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmType_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmType_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmType_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmType_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmType_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmType_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmType_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmType_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmType_CONFIRMATION_REQUEST_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmType_CONFIRMATION_REQUEST_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmType_CONFIRMATION_REQUEST_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmType_CONFIRMATION_REQUEST_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_MISMATCHED_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_MISMATCHED_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_MISMATCHED_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_MISMATCHED_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_UNKNOWN_OR_MISSING_INDIVIDUAL_ALLOC_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_UNKNOWN_OR_MISSING_INDIVIDUAL_ALLOC_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_UNKNOWN_OR_MISSING_INDIVIDUAL_ALLOC_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_UNKNOWN_OR_MISSING_INDIVIDUAL_ALLOC_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_TRANSACTION_NOT_RECOGNIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_TRANSACTION_NOT_RECOGNIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_TRANSACTION_NOT_RECOGNIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_TRANSACTION_NOT_RECOGNIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_DUPLICATE_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_DUPLICATE_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_DUPLICATE_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_DUPLICATE_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_INCORRECT_OR_MISSING_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_INCORRECT_OR_MISSING_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_INCORRECT_OR_MISSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_INCORRECT_OR_MISSING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_COMMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_INCORRECT_OR_MISSING_COMMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_COMMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_INCORRECT_OR_MISSING_COMMISSION));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_SETTL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_INCORRECT_OR_MISSING_SETTL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_SETTL_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_INCORRECT_OR_MISSING_SETTL_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_FUND_ID_OR_FUND_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_INCORRECT_OR_MISSING_FUND_ID_OR_FUND_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_FUND_ID_OR_FUND_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_INCORRECT_OR_MISSING_FUND_ID_OR_FUND_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_INCORRECT_OR_MISSING_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_INCORRECT_OR_MISSING_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_FEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_INCORRECT_OR_MISSING_FEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_FEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_INCORRECT_OR_MISSING_FEES));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_INCORRECT_OR_MISSING_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_INCORRECT_OR_MISSING_TAX));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_INCORRECT_OR_MISSING_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_INCORRECT_OR_MISSING_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_INCORRECT_OR_MISSING_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_INCORRECT_OR_MISSING_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_NET_MONEY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_INCORRECT_OR_MISSING_NET_MONEY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_NET_MONEY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_INCORRECT_OR_MISSING_NET_MONEY));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_TRADE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_INCORRECT_OR_MISSING_TRADE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_TRADE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_INCORRECT_OR_MISSING_TRADE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_SETTL_CCY_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_INCORRECT_OR_MISSING_SETTL_CCY_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_SETTL_CCY_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_INCORRECT_OR_MISSING_SETTL_CCY_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_CAPACITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_INCORRECT_OR_MISSING_CAPACITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_CAPACITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_INCORRECT_OR_MISSING_CAPACITY));
  return pyobj;
}


SWIGINTERN int Swig_var_BookingType_REGULAR_BOOKING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingType_REGULAR_BOOKING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BookingType_REGULAR_BOOKING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BookingType_REGULAR_BOOKING));
  return pyobj;
}


SWIGINTERN int Swig_var_BookingType_CFD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingType_CFD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BookingType_CFD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BookingType_CFD));
  return pyobj;
}


SWIGINTERN int Swig_var_BookingType_TOTAL_RETURN_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingType_TOTAL_RETURN_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BookingType_TOTAL_RETURN_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BookingType_TOTAL_RETURN_SWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocSettlInstType_FULL_DETAILS_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_FULL_DETAILS_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocSettlInstType_FULL_DETAILS_PROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_FULL_DETAILS_PROVIDED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocSettlInstType_SSIDBI_DS_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_SSIDBI_DS_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocSettlInstType_SSIDBI_DS_PROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_SSIDBI_DS_PROVIDED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocSettlInstType_PHONE_FOR_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_PHONE_FOR_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocSettlInstType_PHONE_FOR_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_PHONE_FOR_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_DlvyInstType_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DlvyInstType_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DlvyInstType_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DlvyInstType_SECURITIES));
  return pyobj;
}


SWIGINTERN int Swig_var_DlvyInstType_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DlvyInstType_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DlvyInstType_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DlvyInstType_CASH));
  return pyobj;
}


SWIGINTERN int Swig_var_TerminationType_OVERNIGHT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TerminationType_OVERNIGHT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TerminationType_OVERNIGHT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TerminationType_OVERNIGHT));
  return pyobj;
}


SWIGINTERN int Swig_var_TerminationType_TERM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TerminationType_TERM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TerminationType_TERM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TerminationType_TERM));
  return pyobj;
}


SWIGINTERN int Swig_var_TerminationType_FLEXIBLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TerminationType_FLEXIBLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TerminationType_FLEXIBLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TerminationType_FLEXIBLE));
  return pyobj;
}


SWIGINTERN int Swig_var_TerminationType_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TerminationType_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TerminationType_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TerminationType_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstReqRejCode_UNKNOWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstReqRejCode_UNKNOWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstReqRejCode_UNKNOWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_UNKNOWN_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstReqRejCode_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstReqRejCode_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstReqRejCode_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_WAREHOUSE_RECAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_WAREHOUSE_RECAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_WAREHOUSE_RECAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_WAREHOUSE_RECAP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_REQUEST_TO_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_REQUEST_TO_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_REQUEST_TO_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REQUEST_TO_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_ACCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_ACCEPT_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_ACCEPT_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_ACCEPT_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_ACCEPT_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_COMPLETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_COMPLETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_COMPLETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_COMPLETE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_REVERSE_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_REVERSE_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_REVERSE_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REVERSE_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_GIVEUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_GIVEUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_GIVEUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_GIVEUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_TAKEUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_TAKEUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_TAKEUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_TAKEUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_REVERSAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_REVERSAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_REVERSAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REVERSAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_ALLEGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_ALLEGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_ALLEGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_ALLEGED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_SUB_ALLOCATION_GIVEUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_SUB_ALLOCATION_GIVEUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_SUB_ALLOCATION_GIVEUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_SUB_ALLOCATION_GIVEUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocCancReplaceReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocCancReplaceReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocCancReplaceReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocCancReplaceReason_CANCELLED_BY_GIVEUP_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocCancReplaceReason_CANCELLED_BY_GIVEUP_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocCancReplaceReason_CANCELLED_BY_GIVEUP_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_CANCELLED_BY_GIVEUP_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_CARRIED_CUSTOMER_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_CARRIED_CUSTOMER_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_CARRIED_CUSTOMER_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_CARRIED_CUSTOMER_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_CARRIED_NON_CUSTOMER_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_CARRIED_NON_CUSTOMER_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_CARRIED_NON_CUSTOMER_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_CARRIED_NON_CUSTOMER_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_HOUSE_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_HOUSE_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_HOUSE_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_HOUSE_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_FLOOR_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_FLOOR_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_FLOOR_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_FLOOR_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_CARRIED_NON_CUSTOMER_SIDE_CROSS_MARGINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_CARRIED_NON_CUSTOMER_SIDE_CROSS_MARGINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_CARRIED_NON_CUSTOMER_SIDE_CROSS_MARGINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_CARRIED_NON_CUSTOMER_SIDE_CROSS_MARGINED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_HOUSE_TRADER_CROSS_MARGINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_HOUSE_TRADER_CROSS_MARGINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_HOUSE_TRADER_CROSS_MARGINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_HOUSE_TRADER_CROSS_MARGINED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_PERSON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PERSON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_PERSON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PERSON));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SYSTEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SYSTEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SYSTEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SYSTEM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_APPLICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_APPLICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_APPLICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_APPLICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_FULL_LEGAL_NAME_OF_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FULL_LEGAL_NAME_OF_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_FULL_LEGAL_NAME_OF_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FULL_LEGAL_NAME_OF_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_POSTAL_ADDRESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_POSTAL_ADDRESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_POSTAL_ADDRESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_POSTAL_ADDRESS));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_PHONE_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PHONE_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_PHONE_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PHONE_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_EMAIL_ADDRESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_EMAIL_ADDRESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_EMAIL_ADDRESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_EMAIL_ADDRESS));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_CONTACT_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CONTACT_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_CONTACT_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CONTACT_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SECURITIES_ACCOUNT_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SECURITIES_ACCOUNT_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_REGISTRATION_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTRATION_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_REGISTRATION_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTRATION_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_REGISTERED_ADDRESS_FOR_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTERED_ADDRESS_FOR_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_REGISTERED_ADDRESS_FOR_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTERED_ADDRESS_FOR_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_REGULATORY_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGULATORY_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_REGULATORY_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGULATORY_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_REGISTRATION_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTRATION_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_REGISTRATION_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTRATION_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_CASH_ACCOUNT_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CASH_ACCOUNT_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_CASH_ACCOUNT_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CASH_ACCOUNT_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_BIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_BIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_BIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_BIC));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_REGISTERED_ADDRESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTERED_ADDRESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_REGISTERED_ADDRESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTERED_ADDRESS));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_FUND_ACCOUNT_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FUND_ACCOUNT_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_FUND_ACCOUNT_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FUND_ACCOUNT_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_TELEX_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_TELEX_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_TELEX_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_TELEX_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_FAX_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FAX_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_FAX_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FAX_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SECURITIES_ACCOUNT_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SECURITIES_ACCOUNT_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_CASH_ACCOUNT_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CASH_ACCOUNT_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_CASH_ACCOUNT_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CASH_ACCOUNT_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_DEPARTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_DEPARTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_DEPARTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_DEPARTMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_LOCATION_DESK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_LOCATION_DESK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_LOCATION_DESK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LOCATION_DESK));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_POSITION_ACCOUNT_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_POSITION_ACCOUNT_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_POSITION_ACCOUNT_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_POSITION_ACCOUNT_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SECURITY_LOCATE_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SECURITY_LOCATE_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SECURITY_LOCATE_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SECURITY_LOCATE_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_ELIGIBLE_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_ELIGIBLE_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_ELIGIBLE_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ELIGIBLE_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_PROFESSIONAL_CLIENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PROFESSIONAL_CLIENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_PROFESSIONAL_CLIENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PROFESSIONAL_CLIENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_LOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_LOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_LOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_EXECUTION_VENUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_EXECUTION_VENUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_EXECUTION_VENUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_EXECUTION_VENUE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_ADDRESS_CITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_ADDRESS_CITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_ADDRESS_CITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ADDRESS_CITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_ADDRESS_STATE_OR_PROVINCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_ADDRESS_STATE_OR_PROVINCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_ADDRESS_STATE_OR_PROVINCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ADDRESS_STATE_OR_PROVINCE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_ADDRESS_POSTAL_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_ADDRESS_POSTAL_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_ADDRESS_POSTAL_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ADDRESS_POSTAL_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_ADDRESS_STREET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_ADDRESS_STREET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_ADDRESS_STREET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ADDRESS_STREET));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_ADDRESS_ISO_COUNTRY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_ADDRESS_ISO_COUNTRY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_ADDRESS_ISO_COUNTRY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ADDRESS_ISO_COUNTRY_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_ISO_COUNTRY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_ISO_COUNTRY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_ISO_COUNTRY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ISO_COUNTRY_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_MARKET_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_MARKET_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_MARKET_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_MARKET_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_CUSTOMER_ACCOUNT_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CUSTOMER_ACCOUNT_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_CUSTOMER_ACCOUNT_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CUSTOMER_ACCOUNT_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_OMNIBUS_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_OMNIBUS_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_OMNIBUS_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_OMNIBUS_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_FUNDS_SEGREGATION_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FUNDS_SEGREGATION_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_FUNDS_SEGREGATION_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FUNDS_SEGREGATION_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_GUARANTEE_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_GUARANTEE_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_GUARANTEE_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_GUARANTEE_FUND));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SWAP_DEALER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SWAP_DEALER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SWAP_DEALER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SWAP_DEALER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_MAJOR_PARTICIPANT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_MAJOR_PARTICIPANT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_MAJOR_PARTICIPANT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_MAJOR_PARTICIPANT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_FINANCIAL_ENTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FINANCIAL_ENTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_FINANCIAL_ENTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FINANCIAL_ENTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_US_PERSON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_US_PERSON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_US_PERSON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_US_PERSON));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_REPORTING_ENTITY_INDICATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REPORTING_ENTITY_INDICATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_REPORTING_ENTITY_INDICATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REPORTING_ENTITY_INDICATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_ELECTED_CLEARING_REQUIREMENT_EXCEPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_ELECTED_CLEARING_REQUIREMENT_EXCEPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_ELECTED_CLEARING_REQUIREMENT_EXCEPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ELECTED_CLEARING_REQUIREMENT_EXCEPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_BUSINESS_CENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_BUSINESS_CENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_BUSINESS_CENTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_BUSINESS_CENTER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_REFERENCE_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REFERENCE_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_REFERENCE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REFERENCE_TEXT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SHORT_MARKING_EXEMPT_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SHORT_MARKING_EXEMPT_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SHORT_MARKING_EXEMPT_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SHORT_MARKING_EXEMPT_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_PARENT_FIRM_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PARENT_FIRM_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_PARENT_FIRM_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PARENT_FIRM_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_PARENT_FIRM_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PARENT_FIRM_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_PARENT_FIRM_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PARENT_FIRM_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_DEAL_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_DEAL_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_DEAL_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_DEAL_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SYSTEM_TRADE_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SYSTEM_TRADE_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SYSTEM_TRADE_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SYSTEM_TRADE_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SYSTEM_TRADE_SUB_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SYSTEM_TRADE_SUB_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SYSTEM_TRADE_SUB_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SYSTEM_TRADE_SUB_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_FCM_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FCM_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_FCM_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FCM_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_DLVRY_TRML_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_DLVRY_TRML_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_DLVRY_TRML_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_DLVRY_TRML_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_VOLNTY_RPT_ENTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_VOLNTY_RPT_ENTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_VOLNTY_RPT_ENTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_VOLNTY_RPT_ENTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_RPT_OBLIG_JURSDCTN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_RPT_OBLIG_JURSDCTN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_RPT_OBLIG_JURSDCTN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_RPT_OBLIG_JURSDCTN));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_VOLNTY_RPT_JURSDCTN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_VOLNTY_RPT_JURSDCTN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_VOLNTY_RPT_JURSDCTN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_VOLNTY_RPT_JURSDCTN));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_COMPANY_ACTIVITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_COMPANY_ACTIVITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_COMPANY_ACTIVITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_COMPANY_ACTIVITIES));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_EE_AREA_DOMICILED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_EE_AREA_DOMICILED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_EE_AREA_DOMICILED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_EE_AREA_DOMICILED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_CONTRACT_LINKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CONTRACT_LINKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_CONTRACT_LINKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CONTRACT_LINKED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_CONTRACT_ABOVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CONTRACT_ABOVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_CONTRACT_ABOVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CONTRACT_ABOVE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_VOLNTY_RPT_PTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_VOLNTY_RPT_PTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_VOLNTY_RPT_PTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_VOLNTY_RPT_PTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_END_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_END_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_END_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_END_USER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_LOCATION_OR_JURISDICTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_LOCATION_OR_JURISDICTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_LOCATION_OR_JURISDICTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LOCATION_OR_JURISDICTION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_DERIVATIVES_DEALER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_DERIVATIVES_DEALER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_DERIVATIVES_DEALER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_DERIVATIVES_DEALER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_DOMICILE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_DOMICILE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_DOMICILE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_DOMICILE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_EXEMPT_FROM_RECOGNITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_EXEMPT_FROM_RECOGNITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_EXEMPT_FROM_RECOGNITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_EXEMPT_FROM_RECOGNITION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_PAYER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PAYER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_PAYER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PAYER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_RECEIVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_RECEIVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_RECEIVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_RECEIVER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SYSTEMATIC_INTERNALISER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SYSTEMATIC_INTERNALISER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SYSTEMATIC_INTERNALISER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SYSTEMATIC_INTERNALISER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_PUBLISHING_ENTITY_INDICATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PUBLISHING_ENTITY_INDICATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_PUBLISHING_ENTITY_INDICATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PUBLISHING_ENTITY_INDICATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_FIRST_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FIRST_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_FIRST_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FIRST_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SURNAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SURNAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SURNAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SURNAME));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_DATE_OF_BIRTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_DATE_OF_BIRTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_DATE_OF_BIRTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_DATE_OF_BIRTH));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_ORDER_TRANSMITTING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_ORDER_TRANSMITTING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_ORDER_TRANSMITTING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ORDER_TRANSMITTING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_ORDER_TRANSMITTING_FIRM_BUYER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_ORDER_TRANSMITTING_FIRM_BUYER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_ORDER_TRANSMITTING_FIRM_BUYER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ORDER_TRANSMITTING_FIRM_BUYER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_ORDER_TRANSMITTER_SELLER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_ORDER_TRANSMITTER_SELLER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_ORDER_TRANSMITTER_SELLER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ORDER_TRANSMITTER_SELLER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_LEGAL_ENTITY_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_LEGAL_ENTITY_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_LEGAL_ENTITY_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LEGAL_ENTITY_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SUB_SECTOR_CLASSIFICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SUB_SECTOR_CLASSIFICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SUB_SECTOR_CLASSIFICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SUB_SECTOR_CLASSIFICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_PARTY_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PARTY_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_PARTY_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PARTY_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_LEGAL_REGISTRATION_COUNTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_LEGAL_REGISTRATION_COUNTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_LEGAL_REGISTRATION_COUNTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LEGAL_REGISTRATION_COUNTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocIntermedReqType_PENDING_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocIntermedReqType_PENDING_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocIntermedReqType_PENDING_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_ACCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocIntermedReqType_PENDING_RELEASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocIntermedReqType_PENDING_RELEASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocIntermedReqType_PENDING_RELEASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_RELEASE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocIntermedReqType_PENDING_REVERSAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocIntermedReqType_PENDING_REVERSAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocIntermedReqType_PENDING_REVERSAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_REVERSAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocIntermedReqType_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocIntermedReqType_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocIntermedReqType_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_ACCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocIntermedReqType_BLOCK_LEVEL_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocIntermedReqType_BLOCK_LEVEL_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocIntermedReqType_BLOCK_LEVEL_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_BLOCK_LEVEL_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocIntermedReqType_ACCOUNT_LEVEL_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocIntermedReqType_ACCOUNT_LEVEL_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocIntermedReqType_ACCOUNT_LEVEL_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_ACCOUNT_LEVEL_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueResolution_NO_ACTION_TAKEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_NO_ACTION_TAKEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueResolution_NO_ACTION_TAKEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_NO_ACTION_TAKEN));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueResolution_QUEUE_FLUSHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_QUEUE_FLUSHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueResolution_QUEUE_FLUSHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_QUEUE_FLUSHED));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueResolution_OVERLAY_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_OVERLAY_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueResolution_OVERLAY_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_OVERLAY_LAST));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueResolution_END_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_END_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueResolution_END_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_END_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueAction_NO_ACTION_TAKEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueAction_NO_ACTION_TAKEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueAction_NO_ACTION_TAKEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_NO_ACTION_TAKEN));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueAction_QUEUE_FLUSHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueAction_QUEUE_FLUSHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueAction_QUEUE_FLUSHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_QUEUE_FLUSHED));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueAction_OVERLAY_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueAction_OVERLAY_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueAction_OVERLAY_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_OVERLAY_LAST));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueAction_END_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueAction_END_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueAction_END_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_END_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_AvgPxIndicator_NO_AVERAGE_PRICING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AvgPxIndicator_NO_AVERAGE_PRICING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AvgPxIndicator_NO_AVERAGE_PRICING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_NO_AVERAGE_PRICING));
  return pyobj;
}


SWIGINTERN int Swig_var_AvgPxIndicator_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AvgPxIndicator_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AvgPxIndicator_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_AvgPxIndicator_LAST_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AvgPxIndicator_LAST_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AvgPxIndicator_LAST_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_LAST_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_AvgPxIndicator_NOTIONAL_VALUE_AVERAGE_PX_GROUP_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AvgPxIndicator_NOTIONAL_VALUE_AVERAGE_PX_GROUP_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AvgPxIndicator_NOTIONAL_VALUE_AVERAGE_PX_GROUP_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_NOTIONAL_VALUE_AVERAGE_PX_GROUP_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_AvgPxIndicator_AVERAGE_PRICED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AvgPxIndicator_AVERAGE_PRICED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AvgPxIndicator_AVERAGE_PRICED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_AVERAGE_PRICED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocIndicator_ALLOCATION_NOT_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_NOT_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocIndicator_ALLOCATION_NOT_REQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_NOT_REQUIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocIndicator_ALLOCATION_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocIndicator_ALLOCATION_REQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_REQUIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocIndicator_TRADE_SPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_TRADE_SPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocIndicator_TRADE_SPLIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_TRADE_SPLIT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationCycle_SPECIFIED_EXPIRATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationCycle_SPECIFIED_EXPIRATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationCycle_SPECIFIED_EXPIRATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationCycle_SPECIFIED_EXPIRATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_REGULAR_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_REGULAR_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_REGULAR_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_REGULAR_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_BLOCK_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BLOCK_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_BLOCK_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCK_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EFP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EFP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EFP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EFP));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_LATE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_LATE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_LATE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_LATE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_T_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_T_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_T_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_T_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_WEIGHTED_AVERAGE_PRICE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_WEIGHTED_AVERAGE_PRICE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_WEIGHTED_AVERAGE_PRICE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_WEIGHTED_AVERAGE_PRICE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_BUNCHED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BUNCHED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_BUNCHED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_BUNCHED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_LATE_BUNCHED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_LATE_BUNCHED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_LATE_BUNCHED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_LATE_BUNCHED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_PRIOR_REFERENCE_PRICE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PRIOR_REFERENCE_PRICE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_PRIOR_REFERENCE_PRICE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PRIOR_REFERENCE_PRICE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_AFTER_HOURS_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_AFTER_HOURS_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_AFTER_HOURS_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_AFTER_HOURS_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EXCHANGE_FOR_RISK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_FOR_RISK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EXCHANGE_FOR_RISK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_FOR_RISK));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EXCHANGE_FOR_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_FOR_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EXCHANGE_FOR_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_FOR_SWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_OF_FUTURES_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_OF_FUTURES_FOR));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_TRADING_AT_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_TRADING_AT_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_TRADING_AT_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_TRADING_AT_SETTLEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_ALL_OR_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_ALL_OR_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_FUTURES_LARGE_ORDER_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_FUTURES_LARGE_ORDER_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_FUTURES_LARGE_ORDER_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_FUTURES_LARGE_ORDER_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_OPTION_INTERIM_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_OPTION_INTERIM_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_OPTION_INTERIM_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_OPTION_INTERIM_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_OPTION_CABINET_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_OPTION_CABINET_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_OPTION_CABINET_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_OPTION_CABINET_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_PRIVATELY_NEGOTIATED_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PRIVATELY_NEGOTIATED_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_PRIVATELY_NEGOTIATED_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PRIVATELY_NEGOTIATED_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_ERROR_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_ERROR_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_ERROR_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_ERROR_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_CUM_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_CUM_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_EX_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_EX_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_CUM_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_CUM_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_COUPON));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_EX_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_EX_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_COUPON));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_CASH_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_CASH_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_CASH_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_CASH_SETTLEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_GUARANTEED_DELIVERY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_GUARANTEED_DELIVERY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_GUARANTEED_DELIVERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_GUARANTEED_DELIVERY));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_CUM_RIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_RIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_CUM_RIGHTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_RIGHTS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_EX_RIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_RIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_EX_RIGHTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_RIGHTS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_CUM_BONUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_BONUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_CUM_BONUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_BONUS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_EX_BONUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_BONUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_EX_BONUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_BONUS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_LARGE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_LARGE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_LARGE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_LARGE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_WORKED_PRINCIPAL_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_WORKED_PRINCIPAL_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_WORKED_PRINCIPAL_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_WORKED_PRINCIPAL_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_BLOCK_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BLOCK_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_BLOCK_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCK_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_NAME_CHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_NAME_CHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_NAME_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_NAME_CHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_PORTFOLIO_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PORTFOLIO_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_PORTFOLIO_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PORTFOLIO_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_PROROGATION_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PROROGATION_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_PROROGATION_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PROROGATION_BUY));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_PROROGATION_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PROROGATION_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_PROROGATION_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PROROGATION_SELL));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_OPTION_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_OPTION_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_OPTION_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_OPTION_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_DELTA_NEUTRAL_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_DELTA_NEUTRAL_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_DELTA_NEUTRAL_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_DELTA_NEUTRAL_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_FINANCING_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_FINANCING_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_FINANCING_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_FINANCING_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_NON_STANDARD_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_NON_STANDARD_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_NON_STANDARD_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_NON_STANDARD_SETTLEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_DERIVATIVE_RELATED_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_DERIVATIVE_RELATED_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_DERIVATIVE_RELATED_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_DERIVATIVE_RELATED_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_PORTFOLIO_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PORTFOLIO_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_PORTFOLIO_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PORTFOLIO_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EXCHANGE_GRANTED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_GRANTED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EXCHANGE_GRANTED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_GRANTED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_REPURCHASE_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_REPURCHASE_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_REPURCHASE_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_REPURCHASE_AGREEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_OTC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_OTC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_OTC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_OTC));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EXCHANGE_BASIS_FACILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_BASIS_FACILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EXCHANGE_BASIS_FACILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_BASIS_FACILITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_OPENING_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_OPENING_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_OPENING_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_OPENING_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_NETTED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_NETTED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_NETTED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_NETTED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_BLOCK_SWAP_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BLOCK_SWAP_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_BLOCK_SWAP_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCK_SWAP_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_CREDIT_EVENT_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_CREDIT_EVENT_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_CREDIT_EVENT_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_CREDIT_EVENT_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SUCCESSION_EVENT_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SUCCESSION_EVENT_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SUCCESSION_EVENT_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SUCCESSION_EVENT_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_GIVE_UP_GIVE_IN_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_GIVE_UP_GIVE_IN_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_GIVE_UP_GIVE_IN_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_GIVE_UP_GIVE_IN_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_DARK_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_DARK_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_DARK_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_DARK_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_TECHNICAL_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_TECHNICAL_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_TECHNICAL_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_TECHNICAL_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_BENCHMARK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BENCHMARK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_BENCHMARK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_BENCHMARK));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_PACKAGE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PACKAGE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_PACKAGE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PACKAGE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_ROLL_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_ROLL_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_ROLL_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_ROLL_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_CMTA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_CMTA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_CMTA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CMTA));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_REJECT_FOR_SUBMITTING_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_REJECT_FOR_SUBMITTING_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_REJECT_FOR_SUBMITTING_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_REJECT_FOR_SUBMITTING_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_ADVISORY_FOR_CONTRA_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_ADVISORY_FOR_CONTRA_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_ADVISORY_FOR_CONTRA_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ADVISORY_FOR_CONTRA_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_ONSET_DUE_TO_AN_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_ONSET_DUE_TO_AN_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_ONSET_DUE_TO_AN_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ONSET_DUE_TO_AN_ALLOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_DIFFERENTIAL_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_DIFFERENTIAL_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_DIFFERENTIAL_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_DIFFERENTIAL_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_TRANSACTION_FROM_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_TRANSACTION_FROM_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_TRANSACTION_FROM_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_TRANSACTION_FROM_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_TRANSACTION_FROM_ASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_TRANSACTION_FROM_ASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_TRANSACTION_FROM_ASSIGNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_TRANSACTION_FROM_ASSIGNMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_ACATS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_ACATS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_ACATS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ACATS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_AI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_AI is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_AI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_AI));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_B_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_B is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_B_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_B));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_K_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_K is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_K_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_K));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_LC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_LC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_LC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_LC));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_M_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_M is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_M_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_M));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_N_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_N is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_N_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_N));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_NM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_NM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_NM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_NM));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_NR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_NR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_NR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_NR));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_P_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_P is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_P_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_P));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_PA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_PA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_PA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PA));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_PC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_PC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_PC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PC));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_PN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_PN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_PN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PN));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_R_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_R is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_R_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_R));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_RO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_RO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_RO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_RO));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_RT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_RT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_RT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_RT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_SW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_SW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_SW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_SW));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_T_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_T is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_T_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_T));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_WN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_WN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_WN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_WN));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_WT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_WT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_WT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_WT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_OFF_HOURS_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_OFF_HOURS_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_OFF_HOURS_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_OFF_HOURS_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_ON_HOURS_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_ON_HOURS_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_ON_HOURS_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ON_HOURS_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_OTC_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_OTC_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_OTC_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_OTC_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_CONVERTED_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_CONVERTED_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_CONVERTED_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CONVERTED_SWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_CROSSED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_CROSSED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_CROSSED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CROSSED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_INTERIM_PROTECTED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_INTERIM_PROTECTED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_INTERIM_PROTECTED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_INTERIM_PROTECTED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_LARGE_IN_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_LARGE_IN_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_LARGE_IN_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_LARGE_IN_SCALE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_WASH_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_WASH_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_WASH_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_WASH_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_TRADE_AT_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_TRADE_AT_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_TRADE_AT_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_TRADE_AT_SETTLEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_AUCTION_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_AUCTION_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_AUCTION_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_AUCTION_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_TRADE_AT_MARKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_TRADE_AT_MARKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_TRADE_AT_MARKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_TRADE_AT_MARKER));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_CREDIT_DEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_CREDIT_DEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_CREDIT_DEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CREDIT_DEFAULT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_CREDIT_RESTRUCTURING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_CREDIT_RESTRUCTURING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_CREDIT_RESTRUCTURING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CREDIT_RESTRUCTURING));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_MERGER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_MERGER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_MERGER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_MERGER));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_SPIN_OFF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_SPIN_OFF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_SPIN_OFF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_SPIN_OFF));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_MULTILATERAL_COMPRESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_MULTILATERAL_COMPRESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_MULTILATERAL_COMPRESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_MULTILATERAL_COMPRESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_BALANCING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_BALANCING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_BALANCING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_BALANCING));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_BASIS_TRADE_INDEX_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_BASIS_TRADE_INDEX_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_BASIS_TRADE_INDEX_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_BASIS_TRADE_INDEX_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_TRADE_AT_CASH_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_TRADE_AT_CASH_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_TRADE_AT_CASH_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_TRADE_AT_CASH_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_TRD_SUBMIT_VENUE_CLR_SETTL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_TRD_SUBMIT_VENUE_CLR_SETTL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_TRD_SUBMIT_VENUE_CLR_SETTL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_TRD_SUBMIT_VENUE_CLR_SETTL));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_BILATERAL_COMPRESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_BILATERAL_COMPRESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_BILATERAL_COMPRESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_BILATERAL_COMPRESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_PegMoveType_FLOATING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegMoveType_FLOATING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegMoveType_FLOATING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegMoveType_FLOATING));
  return pyobj;
}


SWIGINTERN int Swig_var_PegMoveType_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegMoveType_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegMoveType_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegMoveType_FIXED));
  return pyobj;
}


SWIGINTERN int Swig_var_PegOffsetType_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegOffsetType_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_PegOffsetType_BASIS_POINTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_BASIS_POINTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegOffsetType_BASIS_POINTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_BASIS_POINTS));
  return pyobj;
}


SWIGINTERN int Swig_var_PegOffsetType_TICKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_TICKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegOffsetType_TICKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_TICKS));
  return pyobj;
}


SWIGINTERN int Swig_var_PegOffsetType_PRICE_TIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_PRICE_TIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegOffsetType_PRICE_TIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_PRICE_TIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PegOffsetType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegOffsetType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PegLimitType_OR_BETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegLimitType_OR_BETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegLimitType_OR_BETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegLimitType_OR_BETTER));
  return pyobj;
}


SWIGINTERN int Swig_var_PegLimitType_STRICT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegLimitType_STRICT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegLimitType_STRICT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegLimitType_STRICT));
  return pyobj;
}


SWIGINTERN int Swig_var_PegLimitType_OR_WORSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegLimitType_OR_WORSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegLimitType_OR_WORSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegLimitType_OR_WORSE));
  return pyobj;
}


SWIGINTERN int Swig_var_PegRoundDirection_MORE_AGGRESSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegRoundDirection_MORE_AGGRESSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegRoundDirection_MORE_AGGRESSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MORE_AGGRESSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_PegRoundDirection_MORE_PASSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegRoundDirection_MORE_PASSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegRoundDirection_MORE_PASSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MORE_PASSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_PegScope_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegScope_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegScope_LOCAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PegScope_NATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_NATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegScope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegScope_NATIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PegScope_GLOBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_GLOBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegScope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegScope_GLOBAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PegScope_NATIONAL_EXCLUDING_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_NATIONAL_EXCLUDING_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegScope_NATIONAL_EXCLUDING_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegScope_NATIONAL_EXCLUDING_LOCAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionMoveType_FLOATING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionMoveType_FLOATING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionMoveType_FLOATING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionMoveType_FLOATING));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionMoveType_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionMoveType_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionMoveType_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionMoveType_FIXED));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionOffsetType_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionOffsetType_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionOffsetType_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionOffsetType_BASIS_POINTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionOffsetType_BASIS_POINTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionOffsetType_BASIS_POINTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_BASIS_POINTS));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionOffsetType_TICKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionOffsetType_TICKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionOffsetType_TICKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_TICKS));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionOffsetType_PRICE_TIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionOffsetType_PRICE_TIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionOffsetType_PRICE_TIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_PRICE_TIER));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionLimitType_OR_BETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionLimitType_OR_BETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionLimitType_OR_BETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_OR_BETTER));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionLimitType_STRICT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionLimitType_STRICT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionLimitType_STRICT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_STRICT));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionLimitType_OR_WORSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionLimitType_OR_WORSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionLimitType_OR_WORSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_OR_WORSE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionRoundDirection_MORE_AGGRESSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionRoundDirection_MORE_AGGRESSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionRoundDirection_MORE_AGGRESSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MORE_AGGRESSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionRoundDirection_MORE_PASSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionRoundDirection_MORE_PASSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionRoundDirection_MORE_PASSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MORE_PASSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionScope_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionScope_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionScope_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_LOCAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionScope_NATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionScope_NATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionScope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_NATIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionScope_GLOBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionScope_GLOBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionScope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_GLOBAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionScope_NATIONAL_EXCLUDING_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionScope_NATIONAL_EXCLUDING_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionScope_NATIONAL_EXCLUDING_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_NATIONAL_EXCLUDING_LOCAL));
  return pyobj;
}


SWIGINTERN int Swig_var_TargetStrategy_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TargetStrategy_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TargetStrategy_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_VWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_TargetStrategy_PARTICIPATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TargetStrategy_PARTICIPATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TargetStrategy_PARTICIPATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_PARTICIPATE));
  return pyobj;
}


SWIGINTERN int Swig_var_TargetStrategy_MININIZE_MARKET_IMPACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TargetStrategy_MININIZE_MARKET_IMPACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TargetStrategy_MININIZE_MARKET_IMPACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_MININIZE_MARKET_IMPACT));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_ADDED_LIQUIDITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_ADDED_LIQUIDITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_ADDED_LIQUIDITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_ADDED_LIQUIDITY));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_REMOVED_LIQUIDITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_REMOVED_LIQUIDITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_REMOVED_LIQUIDITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_REMOVED_LIQUIDITY));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_LIQUIDITY_ROUTED_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_LIQUIDITY_ROUTED_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_LIQUIDITY_ROUTED_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_LIQUIDITY_ROUTED_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_AUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_NEITHER_ADDED_NOR_REMOVED_LIQUIDITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_NEITHER_ADDED_NOR_REMOVED_LIQUIDITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_NEITHER_ADDED_NOR_REMOVED_LIQUIDITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_NEITHER_ADDED_NOR_REMOVED_LIQUIDITY));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_TRIGGERED_STOP_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_TRIGGERED_STOP_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_TRIGGERED_STOP_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_TRIGGERED_STOP_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_TRIGGERED_CONTINGENCY_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_TRIGGERED_CONTINGENCY_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_TRIGGERED_CONTINGENCY_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_TRIGGERED_CONTINGENCY_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_TRIGGERED_MARKET_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_TRIGGERED_MARKET_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_TRIGGERED_MARKET_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_TRIGGERED_MARKET_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_REMOVED_LIQUIDITY_AFTER_FIRM_ORDER_COMMITMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_REMOVED_LIQUIDITY_AFTER_FIRM_ORDER_COMMITMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_REMOVED_LIQUIDITY_AFTER_FIRM_ORDER_COMMITMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_REMOVED_LIQUIDITY_AFTER_FIRM_ORDER_COMMITMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_AUCTION_EXECUTION_AFTER_FIRM_ORDER_COMMITMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_AUCTION_EXECUTION_AFTER_FIRM_ORDER_COMMITMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_AUCTION_EXECUTION_AFTER_FIRM_ORDER_COMMITMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_AUCTION_EXECUTION_AFTER_FIRM_ORDER_COMMITMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_UNKNOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_UNKNOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_UNKNOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_UNKNOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_PublishTrdIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PublishTrdIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PublishTrdIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PublishTrdIndicator_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_PublishTrdIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PublishTrdIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PublishTrdIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PublishTrdIndicator_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_DEALER_SOLD_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_DEALER_SOLD_SHORT));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT));
  return pyobj;
}


SWIGINTERN int Swig_var_QtyType_UNITS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QtyType_UNITS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QtyType_UNITS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QtyType_UNITS));
  return pyobj;
}


SWIGINTERN int Swig_var_QtyType_CONTRACTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QtyType_CONTRACTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QtyType_CONTRACTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QtyType_CONTRACTS));
  return pyobj;
}


SWIGINTERN int Swig_var_QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_SUBMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_SUBMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_SUBMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_SUBMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ALLEGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ALLEGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ACCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_DECLINE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_DECLINE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_DECLINE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_DECLINE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ADDENDUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ADDENDUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ADDENDUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ADDENDUM));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_TRADE_REPORT_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_TRADE_REPORT_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_TRADE_REPORT_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_TRADE_REPORT_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_LOCKED_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_LOCKED_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_LOCKED_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_LOCKED_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_DEFAULTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_DEFAULTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_DEFAULTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_DEFAULTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_INVALID_CMTA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_INVALID_CMTA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_INVALID_CMTA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_INVALID_CMTA));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_PENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_PENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_PENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_PENDED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ALLEGED_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ALLEGED_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ALLEGED_ADDENDUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_ADDENDUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ALLEGED_ADDENDUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_ADDENDUM));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ALLEGED_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ALLEGED_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ALLEGED_TRADE_REPORT_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_TRADE_REPORT_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ALLEGED_TRADE_REPORT_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_TRADE_REPORT_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ALLEGED_TRADE_BREAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_TRADE_BREAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ALLEGED_TRADE_BREAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_TRADE_BREAK));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_VERIFY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_VERIFY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_VERIFY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_VERIFY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_DISPUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_DISPUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_DISPUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_DISPUTE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_NON_MATERIAL_UPDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_NON_MATERIAL_UPDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_NON_MATERIAL_UPDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_NON_MATERIAL_UPDATE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocNoOrdersType_NOT_SPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocNoOrdersType_NOT_SPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocNoOrdersType_NOT_SPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocNoOrdersType_NOT_SPECIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocNoOrdersType_EXPLICIT_LIST_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocNoOrdersType_EXPLICIT_LIST_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocNoOrdersType_EXPLICIT_LIST_PROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocNoOrdersType_EXPLICIT_LIST_PROVIDED));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_PUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_PUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_PUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_PUT));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_CALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_CALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_CALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_CALL));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_TENDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_TENDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_TENDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_TENDER));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_SINKING_FUND_CALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SINKING_FUND_CALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_SINKING_FUND_CALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_SINKING_FUND_CALL));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_ACTIVATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_ACTIVATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_ACTIVATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_ACTIVATION));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_INACTIVIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_INACTIVIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_INACTIVIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_INACTIVIATION));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_LAST_ELIGIBLE_TRADE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_LAST_ELIGIBLE_TRADE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_LAST_ELIGIBLE_TRADE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_LAST_ELIGIBLE_TRADE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_SWAP_START_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_START_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_SWAP_START_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_START_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_SWAP_END_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_END_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_SWAP_END_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_END_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_SWAP_ROLL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_ROLL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_SWAP_ROLL_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_ROLL_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_SWAP_NEXT_START_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_NEXT_START_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_SWAP_NEXT_START_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_NEXT_START_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_SWAP_NEXT_ROLL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_NEXT_ROLL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_SWAP_NEXT_ROLL_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_NEXT_ROLL_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_FIRST_DELIVERY_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_FIRST_DELIVERY_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_FIRST_DELIVERY_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_FIRST_DELIVERY_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_LAST_DELIVERY_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_LAST_DELIVERY_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_LAST_DELIVERY_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_LAST_DELIVERY_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_INITIAL_INVENTORY_DUE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_INITIAL_INVENTORY_DUE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_INITIAL_INVENTORY_DUE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_INITIAL_INVENTORY_DUE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_FINAL_INVENTORY_DUE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_FINAL_INVENTORY_DUE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_FINAL_INVENTORY_DUE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_FINAL_INVENTORY_DUE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_FIRST_INTENT_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_FIRST_INTENT_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_FIRST_INTENT_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_FIRST_INTENT_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_LAST_INTENT_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_LAST_INTENT_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_LAST_INTENT_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_LAST_INTENT_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_POSITION_REMOVAL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_POSITION_REMOVAL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_POSITION_REMOVAL_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_POSITION_REMOVAL_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_MINIMUM_NOTICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_MINIMUM_NOTICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_MINIMUM_NOTICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_MINIMUM_NOTICE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_DELIVERY_START_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_DELIVERY_START_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_DELIVERY_START_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_DELIVERY_START_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_DELIVERY_END_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_DELIVERY_END_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_DELIVERY_END_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_DELIVERY_END_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_FIRST_NOTICE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_FIRST_NOTICE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_FIRST_NOTICE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_FIRST_NOTICE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_LAST_NOTICE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_LAST_NOTICE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_LAST_NOTICE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_LAST_NOTICE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_FIRST_EXERCISE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_FIRST_EXERCISE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_FIRST_EXERCISE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_FIRST_EXERCISE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_REDEMPTION_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_REDEMPTION_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_REDEMPTION_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_REDEMPTION_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_TRD_CNTNTN_EFCTV_DT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_TRD_CNTNTN_EFCTV_DT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_TRD_CNTNTN_EFCTV_DT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_TRD_CNTNTN_EFCTV_DT));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_FLAT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_FLAT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_FLAT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_FLAT));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_ZERO_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ZERO_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_ZERO_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ZERO_COUPON));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_INTEREST_BEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INTEREST_BEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_INTEREST_BEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INTEREST_BEARING));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_NO_PERIODIC_PAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_NO_PERIODIC_PAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_NO_PERIODIC_PAYMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_NO_PERIODIC_PAYMENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_VARIABLE_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_VARIABLE_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_VARIABLE_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_VARIABLE_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_LESS_FEE_FOR_PUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_LESS_FEE_FOR_PUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_LESS_FEE_FOR_PUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_LESS_FEE_FOR_PUT));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_STEPPED_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_STEPPED_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_STEPPED_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_STEPPED_COUPON));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_COUPON_PERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_COUPON_PERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_COUPON_PERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_COUPON_PERIOD));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_WHEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_WHEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_WHEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_WHEN));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ORIGINAL_ISSUE_DISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ORIGINAL_ISSUE_DISCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_CALLABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_CALLABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_CALLABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_ESCROWED_TO_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ESCROWED_TO_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_ESCROWED_TO_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ESCROWED_TO_MATURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ESCROWED_TO_REDEMPTION_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ESCROWED_TO_REDEMPTION_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_PRE_REFUNDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_PRE_REFUNDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_PRE_REFUNDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_PRE_REFUNDED));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_IN_DEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_IN_DEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_IN_DEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_IN_DEFAULT));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_UNRATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_UNRATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_UNRATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_UNRATED));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_TAXABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_TAXABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_TAXABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TAXABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_INDEXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INDEXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_INDEXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INDEXED));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_CALLABLE_WITHOUT_NOTICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_CALLABLE_WITHOUT_NOTICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_CALLABLE_WITHOUT_NOTICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLE_WITHOUT_NOTICE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TEXT));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_INSTRUMENT_DENOMINATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INSTRUMENT_DENOMINATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_INSTRUMENT_DENOMINATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_DENOMINATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_INSTRUMENT_NUMERATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INSTRUMENT_NUMERATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_INSTRUMENT_NUMERATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_NUMERATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_INSTRUMENT_PRICE_PRECISION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INSTRUMENT_PRICE_PRECISION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_INSTRUMENT_PRICE_PRECISION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_PRICE_PRECISION));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_INSTRUMENT_STRIKE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INSTRUMENT_STRIKE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_INSTRUMENT_STRIKE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_STRIKE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_TRADEABLE_INDICATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_TRADEABLE_INDICATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_TRADEABLE_INDICATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TRADEABLE_INDICATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_INSTRUMENT_ELIGIBLE_ANON_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INSTRUMENT_ELIGIBLE_ANON_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_INSTRUMENT_ELIGIBLE_ANON_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_ELIGIBLE_ANON_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_MIN_GUARANTEED_FILL_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_MIN_GUARANTEED_FILL_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_MIN_GUARANTEED_FILL_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_MIN_GUARANTEED_FILL_VOLUME));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_MIN_GUARANTEED_FILL_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_MIN_GUARANTEED_FILL_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_MIN_GUARANTEED_FILL_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_MIN_GUARANTEED_FILL_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_TRADE_AT_SETTLEMENT_ELIGIBILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_TRADE_AT_SETTLEMENT_ELIGIBILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_TRADE_AT_SETTLEMENT_ELIGIBILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TRADE_AT_SETTLEMENT_ELIGIBILITY));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_TEST_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_TEST_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_TEST_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TEST_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_DUMMY_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_DUMMY_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_DUMMY_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_DUMMY_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_NEGATIVE_SETTLEMENT_PRICE_ELIGIBILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_NEGATIVE_SETTLEMENT_PRICE_ELIGIBILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_NEGATIVE_SETTLEMENT_PRICE_ELIGIBILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_NEGATIVE_SETTLEMENT_PRICE_ELIGIBILITY));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_NEGATIVE_STRIKE_PRICE_ELIGIBILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_NEGATIVE_STRIKE_PRICE_ELIGIBILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_NEGATIVE_STRIKE_PRICE_ELIGIBILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_NEGATIVE_STRIKE_PRICE_ELIGIBILITY));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_US_STD_CONTRACT_IND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_US_STD_CONTRACT_IND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_US_STD_CONTRACT_IND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_US_STD_CONTRACT_IND));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_ADMITTED_TO_TRADING_ON_TRADING_VENUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ADMITTED_TO_TRADING_ON_TRADING_VENUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_ADMITTED_TO_TRADING_ON_TRADING_VENUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ADMITTED_TO_TRADING_ON_TRADING_VENUE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_AVERAGE_DAILY_NOTIONAL_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_AVERAGE_DAILY_NOTIONAL_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_AVERAGE_DAILY_NOTIONAL_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_AVERAGE_DAILY_NOTIONAL_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_AVERAGE_DAILY_NUMBER_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_AVERAGE_DAILY_NUMBER_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_AVERAGE_DAILY_NUMBER_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_AVERAGE_DAILY_NUMBER_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_CPProgram_PROGRAM3A3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_PROGRAM3A3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CPProgram_PROGRAM3A3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_PROGRAM3A3));
  return pyobj;
}


SWIGINTERN int Swig_var_CPProgram_PROGRAM42_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_PROGRAM42 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CPProgram_PROGRAM42_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_PROGRAM42));
  return pyobj;
}


SWIGINTERN int Swig_var_CPProgram_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CPProgram_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_CPProgram_PROGRAM3A2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_PROGRAM3A2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CPProgram_PROGRAM3A2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_PROGRAM3A2));
  return pyobj;
}


SWIGINTERN int Swig_var_CPProgram_PROGRAM3A3_AND3C7_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_PROGRAM3A3_AND3C7 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CPProgram_PROGRAM3A3_AND3C7_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_PROGRAM3A3_AND3C7));
  return pyobj;
}


SWIGINTERN int Swig_var_CPProgram_PROGRAM3A4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_PROGRAM3A4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CPProgram_PROGRAM3A4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_PROGRAM3A4));
  return pyobj;
}


SWIGINTERN int Swig_var_CPProgram_PROGRAM3A5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_PROGRAM3A5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CPProgram_PROGRAM3A5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_PROGRAM3A5));
  return pyobj;
}


SWIGINTERN int Swig_var_CPProgram_PROGRAM3A7_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_PROGRAM3A7 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CPProgram_PROGRAM3A7_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_PROGRAM3A7));
  return pyobj;
}


SWIGINTERN int Swig_var_CPProgram_PROGRAM3C7_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_PROGRAM3C7 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CPProgram_PROGRAM3C7_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_PROGRAM3C7));
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeBasis_ABSOLUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeBasis_ABSOLUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeBasis_ABSOLUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_ABSOLUTE));
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeBasis_PER_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeBasis_PER_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeBasis_PER_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_PER_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeBasis_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeBasis_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeBasis_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_LastFragment_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastFragment_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastFragment_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastFragment_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_LastFragment_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastFragment_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastFragment_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastFragment_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_INITIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_INITIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_INITIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_INITIAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_SCHEDULED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_SCHEDULED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_SCHEDULED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_SCHEDULED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_TIME_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_TIME_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_TIME_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_TIME_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_MARGIN_DEFICIENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_MARGIN_DEFICIENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_MARGIN_DEFICIENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_MARGIN_DEFICIENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_MARGIN_EXCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_MARGIN_EXCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_MARGIN_EXCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_MARGIN_EXCESS));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_FORWARD_COLLATERAL_DEMAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_FORWARD_COLLATERAL_DEMAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_FORWARD_COLLATERAL_DEMAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_FORWARD_COLLATERAL_DEMAND));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_EVENT_OF_DEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_EVENT_OF_DEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_EVENT_OF_DEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_EVENT_OF_DEFAULT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_ADVERSE_TAX_EVENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_ADVERSE_TAX_EVENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_ADVERSE_TAX_EVENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_ADVERSE_TAX_EVENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_TRANSFER_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_TRANSFER_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_TRANSFER_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_TRANSFER_DEPOSIT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_TRANSFER_WITHDRAWAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_TRANSFER_WITHDRAWAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_TRANSFER_WITHDRAWAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_TRANSFER_WITHDRAWAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_PLEDGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_PLEDGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_PLEDGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_PLEDGE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_TRADE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_TRADE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_TRADE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_TRADE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_GC_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_GC_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_GC_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_GC_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_COLLATERAL_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_COLLATERAL_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_COLLATERAL_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_COLLATERAL_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_SUBSTITUTION_ELIGIBLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_SUBSTITUTION_ELIGIBLE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_NOT_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_NOT_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_NOT_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_NOT_ASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_PARTIALLY_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_PARTIALLY_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_PARTIALLY_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_PARTIALLY_ASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_FULLY_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_FULLY_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_FULLY_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_FULLY_ASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_OUTSTANDING_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_OUTSTANDING_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_OUTSTANDING_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_OUTSTANDING_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnTransType_RELEASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_RELEASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnTransType_RELEASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_RELEASE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnTransType_REVERSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_REVERSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnTransType_REVERSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_REVERSE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRespType_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRespType_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRespType_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRespType_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRespType_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRespType_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRespType_DECLINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRespType_DECLINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRespType_DECLINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_DECLINED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRespType_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRespType_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRespType_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRespType_TRANSACTION_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRespType_TRANSACTION_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRespType_TRANSACTION_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_TRANSACTION_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRespType_TRANSACTION_COMPLETED_WITH_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRespType_TRANSACTION_COMPLETED_WITH_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRespType_TRANSACTION_COMPLETED_WITH_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_TRANSACTION_COMPLETED_WITH_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRejectReason_UNKNOWN_DEAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_UNKNOWN_DEAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRejectReason_UNKNOWN_DEAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNKNOWN_DEAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_INSUFFICIENT_COLLATERAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_INSUFFICIENT_COLLATERAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_CollStatus_UNASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_UNASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollStatus_UNASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_UNASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollStatus_PARTIALLY_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_PARTIALLY_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollStatus_PARTIALLY_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_PARTIALLY_ASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollStatus_ASSIGNMENT_PROPOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_ASSIGNMENT_PROPOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollStatus_ASSIGNMENT_PROPOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_ASSIGNMENT_PROPOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollStatus_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollStatus_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_ASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollStatus_CHALLENGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_CHALLENGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollStatus_CHALLENGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_CHALLENGED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollStatus_REUSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_REUSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollStatus_REUSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_REUSED));
  return pyobj;
}


SWIGINTERN int Swig_var_LastRptRequested_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastRptRequested_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastRptRequested_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastRptRequested_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_LastRptRequested_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastRptRequested_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastRptRequested_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastRptRequested_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryType_VERSUS_PAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_VERSUS_PAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryType_VERSUS_PAYMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_VERSUS_PAYMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryType_FREE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_FREE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryType_FREE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_FREE));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryType_TRI_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_TRI_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryType_TRI_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_TRI_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryType_HOLD_IN_CUSTODY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_HOLD_IN_CUSTODY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryType_HOLD_IN_CUSTODY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_HOLD_IN_CUSTODY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryType_DELIVER_BY_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_DELIVER_BY_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryType_DELIVER_BY_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_DELIVER_BY_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_UserRequestType_LOG_ON_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_LOG_ON_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserRequestType_LOG_ON_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_LOG_ON_USER));
  return pyobj;
}


SWIGINTERN int Swig_var_UserRequestType_LOG_OFF_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_LOG_OFF_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserRequestType_LOG_OFF_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_LOG_OFF_USER));
  return pyobj;
}


SWIGINTERN int Swig_var_UserRequestType_CHANGE_PASSWORD_FOR_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_CHANGE_PASSWORD_FOR_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserRequestType_CHANGE_PASSWORD_FOR_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_CHANGE_PASSWORD_FOR_USER));
  return pyobj;
}


SWIGINTERN int Swig_var_UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_UserRequestType_REQUEST_THROTTLE_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_REQUEST_THROTTLE_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserRequestType_REQUEST_THROTTLE_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_REQUEST_THROTTLE_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_LOGGED_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_LOGGED_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_LOGGED_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_LOGGED_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_NOT_LOGGED_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_NOT_LOGGED_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_NOT_LOGGED_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_NOT_LOGGED_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_USER_NOT_RECOGNISED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_USER_NOT_RECOGNISED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_USER_NOT_RECOGNISED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_USER_NOT_RECOGNISED));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_PASSWORD_INCORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_PASSWORD_INCORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_PASSWORD_INCORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_PASSWORD_INCORRECT));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_PASSWORD_CHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_PASSWORD_CHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_PASSWORD_CHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_PASSWORD_CHANGED));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_SESSION_SHUTDOWN_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_SESSION_SHUTDOWN_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_SESSION_SHUTDOWN_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_SESSION_SHUTDOWN_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_THROTTLE_PARAMETERS_CHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_THROTTLE_PARAMETERS_CHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_THROTTLE_PARAMETERS_CHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_THROTTLE_PARAMETERS_CHANGED));
  return pyobj;
}


SWIGINTERN int Swig_var_StatusValue_CONNECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_CONNECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatusValue_CONNECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_CONNECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_StatusValue_NOT_CONNECTED_UNEXPECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_NOT_CONNECTED_UNEXPECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatusValue_NOT_CONNECTED_UNEXPECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_NOT_CONNECTED_UNEXPECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_StatusValue_NOT_CONNECTED_EXPECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_NOT_CONNECTED_EXPECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatusValue_NOT_CONNECTED_EXPECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_NOT_CONNECTED_EXPECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_StatusValue_IN_PROCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_IN_PROCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatusValue_IN_PROCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_IN_PROCESS));
  return pyobj;
}


SWIGINTERN int Swig_var_NetworkRequestType_SNAPSHOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkRequestType_SNAPSHOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetworkRequestType_SNAPSHOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_SNAPSHOT));
  return pyobj;
}


SWIGINTERN int Swig_var_NetworkRequestType_SUBSCRIBE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkRequestType_SUBSCRIBE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetworkRequestType_SUBSCRIBE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_SUBSCRIBE));
  return pyobj;
}


SWIGINTERN int Swig_var_NetworkRequestType_STOP_SUBSCRIBING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkRequestType_STOP_SUBSCRIBING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetworkRequestType_STOP_SUBSCRIBING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_STOP_SUBSCRIBING));
  return pyobj;
}


SWIGINTERN int Swig_var_NetworkRequestType_LEVEL_OF_DETAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkRequestType_LEVEL_OF_DETAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetworkRequestType_LEVEL_OF_DETAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_LEVEL_OF_DETAIL));
  return pyobj;
}


SWIGINTERN int Swig_var_NetworkStatusResponseType_FULL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkStatusResponseType_FULL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetworkStatusResponseType_FULL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkStatusResponseType_FULL));
  return pyobj;
}


SWIGINTERN int Swig_var_NetworkStatusResponseType_INCREMENTAL_UPDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkStatusResponseType_INCREMENTAL_UPDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetworkStatusResponseType_INCREMENTAL_UPDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkStatusResponseType_INCREMENTAL_UPDATE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_ACCEPTED_WITH_ERRORS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_ACCEPTED_WITH_ERRORS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_ACCEPTED_WITH_ERRORS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_ACCEPTED_WITH_ERRORS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_CANCELLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_CANCELLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_CANCELLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_CANCELLED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_PENDING_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_PENDING_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_PENDING_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_PENDING_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_PENDING_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_PENDING_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_PENDING_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_PENDING_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_PENDING_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_PENDING_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_PENDING_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_PENDING_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_TERMINATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_TERMINATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_TERMINATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_TERMINATED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_PENDING_VERIFICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_PENDING_VERIFICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_PENDING_VERIFICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_PENDING_VERIFICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_DEEMED_VERIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_DEEMED_VERIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_DEEMED_VERIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_DEEMED_VERIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_VERIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_VERIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_VERIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_VERIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_DISPUTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_DISPUTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_DISPUTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_DISPUTED));
  return pyobj;
}


SWIGINTERN int Swig_var_AffirmStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AffirmStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AffirmStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_AffirmStatus_CONFIRM_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AffirmStatus_CONFIRM_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AffirmStatus_CONFIRM_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_CONFIRM_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_AffirmStatus_AFFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AffirmStatus_AFFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AffirmStatus_AFFIRMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_AFFIRMED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAction_RETAIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAction_RETAIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAction_RETAIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAction_RETAIN));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAction_ADD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAction_ADD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAction_ADD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAction_ADD));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAction_REMOVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAction_REMOVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAction_REMOVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAction_REMOVE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryStatus_ACCEPTED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_ACCEPTED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryStatus_ACCEPTED_WITH_WARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_ACCEPTED_WITH_WARNINGS));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryStatus_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryStatus_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_COMPLETED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryStatus_COMPLETED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_COMPLETED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryStatus_COMPLETED_WITH_WARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_COMPLETED_WITH_WARNINGS));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_INVALID_PARTIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_INVALID_PARTIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_INVALID_PARTIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_PARTIES));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_INVALID_DESTINATION_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_INVALID_DESTINATION_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_INVALID_DESTINATION_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_DESTINATION_REQUESTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_INT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_INT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_INT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_INT));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_LENGTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_LENGTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_LENGTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LENGTH));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_NUM_IN_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_NUM_IN_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_NUM_IN_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_NUM_IN_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_SEQ_NUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_SEQ_NUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_SEQ_NUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_SEQ_NUM));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_TAG_NUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_TAG_NUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_TAG_NUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TAG_NUM));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_FLOAT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_FLOAT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_FLOAT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_FLOAT));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_QTY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_PRICE_OFFSET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_PRICE_OFFSET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_PRICE_OFFSET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PRICE_OFFSET));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_AMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_AMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_AMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_AMT));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_CHAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_CHAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_CHAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_CHAR));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_BOOLEAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_BOOLEAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_BOOLEAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_BOOLEAN));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_STRING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_STRING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_STRING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_STRING));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_MULTIPLE_CHAR_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_MULTIPLE_CHAR_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_MULTIPLE_CHAR_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MULTIPLE_CHAR_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_CURRENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_MONTH_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_MONTH_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_MONTH_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MONTH_YEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_UTC_TIMESTAMP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_UTC_TIMESTAMP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_UTC_TIMESTAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTC_TIMESTAMP));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_UTC_TIME_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_UTC_TIME_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_UTC_TIME_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTC_TIME_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_LOCAL_MKT_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_LOCAL_MKT_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_LOCAL_MKT_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LOCAL_MKT_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_UTC_DATE_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_UTC_DATE_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_UTC_DATE_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTC_DATE_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_DATA));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_MULTIPLE_STRING_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_MULTIPLE_STRING_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_MULTIPLE_STRING_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MULTIPLE_STRING_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_COUNTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_COUNTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_COUNTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_COUNTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_LANGUAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_LANGUAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_LANGUAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LANGUAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_TZ_TIME_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_TZ_TIME_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_TZ_TIME_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TZ_TIME_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_TZ_TIMESTAMP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_TZ_TIMESTAMP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_TZ_TIMESTAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TZ_TIMESTAMP));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_TENOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_TENOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_TENOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TENOR));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityStatus_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityStatus_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_ACTIVE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityStatus_INACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_INACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityStatus_INACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_INACTIVE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityStatus_ACTIVE_CLOSING_ORDERS_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_ACTIVE_CLOSING_ORDERS_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityStatus_ACTIVE_CLOSING_ORDERS_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_ACTIVE_CLOSING_ORDERS_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityStatus_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityStatus_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_EXPIRED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityStatus_DELISTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_DELISTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityStatus_DELISTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_DELISTED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityStatus_KNOCKED_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_KNOCKED_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityStatus_KNOCKED_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_KNOCKED_OUT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityStatus_KNOCK_OUT_REVOKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_KNOCK_OUT_REVOKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityStatus_KNOCK_OUT_REVOKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_KNOCK_OUT_REVOKED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityStatus_PENDING_EXPIRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_PENDING_EXPIRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityStatus_PENDING_EXPIRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_PENDING_EXPIRY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityStatus_SUSPENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_SUSPENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityStatus_SUSPENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_SUSPENDED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityStatus_PUBLISHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_PUBLISHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityStatus_PUBLISHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_PUBLISHED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityStatus_PENDING_DELETION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_PENDING_DELETION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityStatus_PENDING_DELETION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_PENDING_DELETION);
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingCashType_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingCashType_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingCashType_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnderlyingCashType_FIXED);
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingCashType_DIFF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingCashType_DIFF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingCashType_DIFF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnderlyingCashType_DIFF);
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingSettlementType_T_PLUS1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingSettlementType_T_PLUS1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingSettlementType_T_PLUS1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingSettlementType_T_PLUS1));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingSettlementType_T_PLUS3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingSettlementType_T_PLUS3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingSettlementType_T_PLUS3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingSettlementType_T_PLUS3));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingSettlementType_T_PLUS4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingSettlementType_T_PLUS4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingSettlementType_T_PLUS4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingSettlementType_T_PLUS4));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityUpdateAction_ADD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityUpdateAction_ADD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityUpdateAction_ADD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_ADD));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityUpdateAction_DELETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityUpdateAction_DELETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityUpdateAction_DELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_DELETE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityUpdateAction_MODIFY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityUpdateAction_MODIFY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityUpdateAction_MODIFY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_MODIFY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpType_AUTO_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_AUTO_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpType_AUTO_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpType_AUTO_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpType_NON_AUTO_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_NON_AUTO_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpType_NON_AUTO_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpType_NON_AUTO_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpType_FINAL_WILL_BE_EXERCISED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_FINAL_WILL_BE_EXERCISED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpType_FINAL_WILL_BE_EXERCISED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpType_FINAL_WILL_BE_EXERCISED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpType_CONTRARY_INTENTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_CONTRARY_INTENTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpType_CONTRARY_INTENTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpType_CONTRARY_INTENTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpType_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpType_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpType_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_IndividualAllocType_SUB_ALLOCATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IndividualAllocType_SUB_ALLOCATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IndividualAllocType_SUB_ALLOCATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::IndividualAllocType_SUB_ALLOCATE));
  return pyobj;
}


SWIGINTERN int Swig_var_IndividualAllocType_THIRD_PARTY_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IndividualAllocType_THIRD_PARTY_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IndividualAllocType_THIRD_PARTY_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::IndividualAllocType_THIRD_PARTY_ALLOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_UnitofMeasure_BARRELS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitofMeasure_BARRELS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitofMeasure_BARRELS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitofMeasure_BARRELS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitofMeasure_BILLION_CUBIC_FEET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitofMeasure_BILLION_CUBIC_FEET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitofMeasure_BILLION_CUBIC_FEET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitofMeasure_BILLION_CUBIC_FEET);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitofMeasure_BUSHELS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitofMeasure_BUSHELS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitofMeasure_BUSHELS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitofMeasure_BUSHELS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitofMeasure_POUNDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitofMeasure_POUNDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitofMeasure_POUNDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitofMeasure_POUNDS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitofMeasure_GALLONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitofMeasure_GALLONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitofMeasure_GALLONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitofMeasure_GALLONS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitofMeasure_MILLION_BARRELS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitofMeasure_MILLION_BARRELS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitofMeasure_MILLION_BARRELS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitofMeasure_MILLION_BARRELS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitofMeasure_ONE_MILLION_BTU_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitofMeasure_ONE_MILLION_BTU is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitofMeasure_ONE_MILLION_BTU_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitofMeasure_ONE_MILLION_BTU);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitofMeasure_MEGAWATT_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitofMeasure_MEGAWATT_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitofMeasure_MEGAWATT_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitofMeasure_MEGAWATT_HOURS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitofMeasure_TROY_OUNCES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitofMeasure_TROY_OUNCES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitofMeasure_TROY_OUNCES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitofMeasure_TROY_OUNCES);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitofMeasure_METRIC_TONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitofMeasure_METRIC_TONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitofMeasure_METRIC_TONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitofMeasure_METRIC_TONS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitofMeasure_TONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitofMeasure_TONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitofMeasure_TONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitofMeasure_TONS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitofMeasure_US_DOLLARS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitofMeasure_US_DOLLARS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitofMeasure_US_DOLLARS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitofMeasure_US_DOLLARS);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_HOUR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_HOUR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_HOUR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_HOUR);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_MINUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_MINUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_MINUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_MINUTE);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_SECOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_SECOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_SECOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_SECOND);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_WEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_WEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_WEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_WEEK);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_QUARTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_QUARTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_QUARTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_QUARTER);
  return pyobj;
}


SWIGINTERN int Swig_var_AllocMethod_AUTOMATIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocMethod_AUTOMATIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocMethod_AUTOMATIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocMethod_AUTOMATIC));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocMethod_GUARANTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocMethod_GUARANTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocMethod_GUARANTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocMethod_GUARANTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocMethod_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocMethod_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocMethod_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocMethod_MANUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocMethod_BROKER_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocMethod_BROKER_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocMethod_BROKER_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocMethod_BROKER_ASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_AsOfIndicator_FALSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AsOfIndicator_FALSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AsOfIndicator_FALSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AsOfIndicator_FALSE));
  return pyobj;
}


SWIGINTERN int Swig_var_AsOfIndicator_TRUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AsOfIndicator_TRUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AsOfIndicator_TRUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AsOfIndicator_TRUE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDBookType_TOP_OF_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDBookType_TOP_OF_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDBookType_TOP_OF_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDBookType_TOP_OF_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_MDBookType_PRICE_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDBookType_PRICE_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDBookType_PRICE_DEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDBookType_PRICE_DEPTH));
  return pyobj;
}


SWIGINTERN int Swig_var_MDBookType_ORDER_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDBookType_ORDER_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDBookType_ORDER_DEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDBookType_ORDER_DEPTH));
  return pyobj;
}


SWIGINTERN int Swig_var_MDOriginType_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDOriginType_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_MDOriginType_OFF_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_OFF_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDOriginType_OFF_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_OFF_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_MDOriginType_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDOriginType_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDOriginType_QUOTE_DRIVEN_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_QUOTE_DRIVEN_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDOriginType_QUOTE_DRIVEN_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_QUOTE_DRIVEN_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MDOriginType_DARK_ORDER_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_DARK_ORDER_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDOriginType_DARK_ORDER_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_DARK_ORDER_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_MDOriginType_AUCTION_DRIVEN_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_AUCTION_DRIVEN_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDOriginType_AUCTION_DRIVEN_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_AUCTION_DRIVEN_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MDOriginType_QUOTE_NEGOTIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_QUOTE_NEGOTIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDOriginType_QUOTE_NEGOTIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_QUOTE_NEGOTIATION));
  return pyobj;
}


SWIGINTERN int Swig_var_MDOriginType_VOICE_NEGOTIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_VOICE_NEGOTIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDOriginType_VOICE_NEGOTIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_VOICE_NEGOTIATION));
  return pyobj;
}


SWIGINTERN int Swig_var_MDOriginType_HYBRID_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_HYBRID_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDOriginType_HYBRID_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_HYBRID_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_ADD_ON_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_ADD_ON_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_ADD_ON_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_ADD_ON_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_ALL_OR_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_ALL_OR_NONE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_CASH_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_CASH_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_CASH_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_CASH_NOT_HELD);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_DIRECTED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_DIRECTED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_DIRECTED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_DIRECTED_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_FILL_OR_KILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_FILL_OR_KILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_FILL_OR_KILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_FILL_OR_KILL);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_IMBALANCE_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_IMBALANCE_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_IMBALANCE_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_IMBALANCE_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_IMMEDIATE_OR_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_IMMEDIATE_OR_CANCEL);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_LIMIT_ON_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_LIMIT_ON_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_LIMIT_ON_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_LIMIT_ON_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_LIMIT_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_LIMIT_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_LIMIT_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_LIMIT_ON_CLOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_MARKET_AT_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MARKET_AT_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_MARKET_AT_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_AT_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_MARKET_AT_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MARKET_AT_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_MARKET_AT_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_AT_CLOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_MARKET_ON_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MARKET_ON_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_MARKET_ON_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_ON_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_MARKET_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MARKET_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_MARKET_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_ON_CLOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_MINIMUM_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MINIMUM_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_MINIMUM_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MINIMUM_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_NOT_HELD);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_OVER_THE_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_OVER_THE_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_OVER_THE_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_OVER_THE_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_PEGGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_PEGGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_PEGGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_PEGGED);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_RESERVE_SIZE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_RESERVE_SIZE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_RESERVE_SIZE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_RESERVE_SIZE_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_STOP_STOCK_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_STOP_STOCK_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_STOP_STOCK_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_STOP_STOCK_TRANSACTION);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_SCALE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_TIME_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_TIME_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_TIME_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_TIME_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_TRAILING_STOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_TRAILING_STOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_TRAILING_STOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_TRAILING_STOP);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_WORK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_WORK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_WORK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_WORK);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_PHONE_SIMPLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_PHONE_SIMPLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_PHONE_SIMPLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_PHONE_SIMPLE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_PHONE_COMPLEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_PHONE_COMPLEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_PHONE_COMPLEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_PHONE_COMPLEX);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_FCM_PROVIDED_SCREEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_FCM_PROVIDED_SCREEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_FCM_PROVIDED_SCREEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_FCM_PROVIDED_SCREEN);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_OTHER_PROVIDED_SCREEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_OTHER_PROVIDED_SCREEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_OTHER_PROVIDED_SCREEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_OTHER_PROVIDED_SCREEN);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_CLIENT_PROVIDED_PLATFORM_CONTROLLED_BY_FCM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_CLIENT_PROVIDED_PLATFORM_CONTROLLED_BY_FCM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_CLIENT_PROVIDED_PLATFORM_CONTROLLED_BY_FCM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_CLIENT_PROVIDED_PLATFORM_CONTROLLED_BY_FCM);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_CLIENT_PROVIDED_PLATFORM_DIRECT_TO_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_CLIENT_PROVIDED_PLATFORM_DIRECT_TO_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_CLIENT_PROVIDED_PLATFORM_DIRECT_TO_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_CLIENT_PROVIDED_PLATFORM_DIRECT_TO_EXCHANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_ALGO_ENGINE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_ALGO_ENGINE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_ALGO_ENGINE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_ALGO_ENGINE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_PRICE_AT_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_PRICE_AT_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_PRICE_AT_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_PRICE_AT_EXECUTION);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_DESK_ELECTRONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_DESK_ELECTRONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_DESK_ELECTRONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_DESK_ELECTRONIC);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_DESK_PIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_DESK_PIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_DESK_PIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_DESK_PIT);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_CLIENT_ELECTRONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_CLIENT_ELECTRONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_CLIENT_ELECTRONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_CLIENT_ELECTRONIC);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_CLIENT_PIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_CLIENT_PIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_CLIENT_PIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_CLIENT_PIT);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_CONDITIONAL_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_CONDITIONAL_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_CONDITIONAL_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_CONDITIONAL_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_CASH);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_DISCRETIONARY_LIMIT_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_DISCRETIONARY_LIMIT_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_DISCRETIONARY_LIMIT_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_DISCRETIONARY_LIMIT_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_INTRA_DAY_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_INTRA_DAY_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_INTRA_DAY_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_INTRA_DAY_CROSS);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_INTERMARKET_SWEEP_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_INTERMARKET_SWEEP_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_INTERMARKET_SWEEP_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_INTERMARKET_SWEEP_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_MERGER_RELATED_TRANSFER_POSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MERGER_RELATED_TRANSFER_POSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_MERGER_RELATED_TRANSFER_POSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MERGER_RELATED_TRANSFER_POSITION);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_MARKET_TO_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MARKET_TO_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_MARKET_TO_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_TO_LIMIT);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_NEXT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_NEXT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_NEXT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_NEXT_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_OPTIONS_RELATED_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_OPTIONS_RELATED_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_OPTIONS_RELATED_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_OPTIONS_RELATED_TRANSACTION);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_SELLERS_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_SELLERS_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_SELLERS_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_SELLERS_OPTION);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_STAY_ON_OFFERSIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_STAY_ON_OFFERSIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_STAY_ON_OFFERSIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_STAY_ON_OFFERSIDE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_GO_ALONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_GO_ALONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_GO_ALONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_GO_ALONG);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_PARTICIPATE_DO_NOT_INITIATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_PARTICIPATE_DO_NOT_INITIATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_PARTICIPATE_DO_NOT_INITIATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_PARTICIPATE_DO_NOT_INITIATE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_STRICT_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_STRICT_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_STRICT_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_STRICT_SCALE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_TRY_TO_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_TRY_TO_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_TRY_TO_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_TRY_TO_SCALE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_STAY_ON_BIDSIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_STAY_ON_BIDSIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_STAY_ON_BIDSIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_STAY_ON_BIDSIDE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_NO_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_NO_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_NO_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_NO_CROSS);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_OK_TO_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_OK_TO_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_OK_TO_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_OK_TO_CROSS);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_CALL_FIRST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_CALL_FIRST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_CALL_FIRST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_CALL_FIRST);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_PERCENT_OF_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_PERCENT_OF_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_PERCENT_OF_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_PERCENT_OF_VOLUME);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_REINSTATE_ON_SYSTEM_FAILURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_REINSTATE_ON_SYSTEM_FAILURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_REINSTATE_ON_SYSTEM_FAILURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_REINSTATE_ON_SYSTEM_FAILURE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_INSTITUTION_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_INSTITUTION_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_INSTITUTION_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_INSTITUTION_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_REINSTATE_ON_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_REINSTATE_ON_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_REINSTATE_ON_TRADING_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_REINSTATE_ON_TRADING_HALT);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_CANCEL_ON_TRADING_HALF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_CANCEL_ON_TRADING_HALF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_CANCEL_ON_TRADING_HALF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_CANCEL_ON_TRADING_HALF);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_LAST_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_LAST_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_LAST_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_LAST_PEG);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_MID_PRICE_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MID_PRICE_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_MID_PRICE_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MID_PRICE_PEG);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_NON_NEGOTIABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_NON_NEGOTIABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_NON_NEGOTIABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_NON_NEGOTIABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_OPENING_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_OPENING_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_OPENING_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_OPENING_PEG);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_MARKET_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MARKET_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_MARKET_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_PEG);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_CANCEL_ON_SYSTEM_FAILURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_CANCEL_ON_SYSTEM_FAILURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_CANCEL_ON_SYSTEM_FAILURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_CANCEL_ON_SYSTEM_FAILURE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_PRIMARY_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_PRIMARY_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_PRIMARY_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_PRIMARY_PEG);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_SUSPEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_SUSPEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_SUSPEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_SUSPEND);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_FIXED_PEG_TO_LOCAL_BBO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_FIXED_PEG_TO_LOCAL_BBO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_FIXED_PEG_TO_LOCAL_BBO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_FIXED_PEG_TO_LOCAL_BBO);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_PEG_TO_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_PEG_TO_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_PEG_TO_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_PEG_TO_VWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_TRADE_ALONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_TRADE_ALONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_TRADE_ALONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_TRADE_ALONG);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_TRY_TO_STOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_TRY_TO_STOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_TRY_TO_STOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_TRY_TO_STOP);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_CANCEL_IF_NOT_BEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_CANCEL_IF_NOT_BEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_CANCEL_IF_NOT_BEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_CANCEL_IF_NOT_BEST);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_STRICT_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_STRICT_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_STRICT_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_STRICT_LIMIT);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_IGNORE_PRICE_VALIDITY_CHECKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_IGNORE_PRICE_VALIDITY_CHECKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_IGNORE_PRICE_VALIDITY_CHECKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_IGNORE_PRICE_VALIDITY_CHECKS);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_PEG_TO_LIMIT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_PEG_TO_LIMIT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_PEG_TO_LIMIT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_PEG_TO_LIMIT_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_WORK_TO_TARGET_STRATEGY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_WORK_TO_TARGET_STRATEGY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_WORK_TO_TARGET_STRATEGY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_WORK_TO_TARGET_STRATEGY);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_G_ORDER_AND_FCMAP_IOR_FIX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_G_ORDER_AND_FCMAP_IOR_FIX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_G_ORDER_AND_FCMAP_IOR_FIX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_G_ORDER_AND_FCMAP_IOR_FIX);
  return pyobj;
}


SWIGINTERN int Swig_var_OrderHandlingInstSource_NASDOATS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderHandlingInstSource_NASDOATS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderHandlingInstSource_NASDOATS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderHandlingInstSource_NASDOATS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderHandlingInstSource_FINRAOATS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderHandlingInstSource_FINRAOATS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderHandlingInstSource_FINRAOATS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderHandlingInstSource_FINRAOATS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderHandlingInstSource_FIA_EXECUTION_SOURCE_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderHandlingInstSource_FIA_EXECUTION_SOURCE_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderHandlingInstSource_FIA_EXECUTION_SOURCE_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderHandlingInstSource_FIA_EXECUTION_SOURCE_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_AGENCY);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_ARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_ARBITRAGE);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_DERIVATIVES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_DERIVATIVES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_DERIVATIVES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_DERIVATIVES);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_INTERNATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_INTERNATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_INTERNATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_INTERNATIONAL);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_INSTITUTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_INSTITUTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_INSTITUTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_INSTITUTIONAL);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_OTHER);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_PREFERRED_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_PREFERRED_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_PREFERRED_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_PREFERRED_TRADING);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_PROPRIETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_PROPRIETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_PROPRIETARY);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_PROGRAM_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_PROGRAM_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_PROGRAM_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_PROGRAM_TRADING);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_SALES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_SALES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_SALES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_SALES);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_TRADING);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_BLOCK_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_BLOCK_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_BLOCK_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_BLOCK_TRADING);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_CONVERTIBLE_DESK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_CONVERTIBLE_DESK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_CONVERTIBLE_DESK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_CONVERTIBLE_DESK);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_CENTRAL_RISK_BOOKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_CENTRAL_RISK_BOOKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_CENTRAL_RISK_BOOKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_CENTRAL_RISK_BOOKS);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_EQUITY_CAPITAL_MARKETS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_EQUITY_CAPITAL_MARKETS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_EQUITY_CAPITAL_MARKETS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_EQUITY_CAPITAL_MARKETS);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_SWAPS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_SWAPS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_SWAPS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_SWAPS);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_TRADING_DESK_SYSTEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_TRADING_DESK_SYSTEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_TRADING_DESK_SYSTEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_TRADING_DESK_SYSTEM);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_TREASURY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_TREASURY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_TREASURY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_TREASURY);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_FLOOR_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_FLOOR_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_FLOOR_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_FLOOR_BROKER);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskTypeSource_NASDOATS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskTypeSource_NASDOATS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskTypeSource_NASDOATS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeskTypeSource_NASDOATS));
  return pyobj;
}


SWIGINTERN int Swig_var_DeskTypeSource_FINRAOATS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskTypeSource_FINRAOATS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskTypeSource_FINRAOATS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeskTypeSource_FINRAOATS));
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_ADD_ON_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_ADD_ON_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_ADD_ON_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_ADD_ON_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_ALL_OR_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_ALL_OR_NONE);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_CASH_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_CASH_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_CASH_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_CASH_NOT_HELD);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_DIRECTED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_DIRECTED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_DIRECTED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_DIRECTED_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_FILL_OR_KILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_FILL_OR_KILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_FILL_OR_KILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_FILL_OR_KILL);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_IMBALANCE_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_IMBALANCE_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_IMBALANCE_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_IMBALANCE_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_LIMIT_ON_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_LIMIT_ON_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_LIMIT_ON_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_LIMIT_ON_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_LIMIT_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_LIMIT_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_LIMIT_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_LIMIT_ON_CLOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_MARKET_AT_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MARKET_AT_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_MARKET_AT_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_AT_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_MARKET_AT_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MARKET_AT_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_MARKET_AT_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_AT_CLOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_MARKET_ON_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MARKET_ON_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_MARKET_ON_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_ON_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_MARKET_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MARKET_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_MARKET_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_ON_CLOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_MINIMUM_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MINIMUM_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_MINIMUM_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MINIMUM_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_NOT_HELD);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_OVER_THE_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_OVER_THE_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_OVER_THE_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_OVER_THE_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_PEGGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_PEGGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_PEGGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_PEGGED);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_RESERVE_SIZE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_RESERVE_SIZE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_RESERVE_SIZE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_RESERVE_SIZE_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_STOP_STOCK_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_STOP_STOCK_TRANSACTION);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_SCALE);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_TIME_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_TIME_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_TIME_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_TIME_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_TRAILING_STOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_TRAILING_STOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_TRAILING_STOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_TRAILING_STOP);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_WORK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_WORK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_WORK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_WORK);
  return pyobj;
}


SWIGINTERN int Swig_var_ExecAckStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecAckStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecAckStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecAckStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecAckStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecAckStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecAckStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecAckStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecAckStatus_DON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecAckStatus_DON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecAckStatus_DON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecAckStatus_DON));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecAckStatus_DONT_KNOW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecAckStatus_DONT_KNOW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecAckStatus_DONT_KNOW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecAckStatus_DONT_KNOW));
  return pyobj;
}


SWIGINTERN int Swig_var_CollApplType_SPECIFIC_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollApplType_SPECIFIC_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollApplType_SPECIFIC_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollApplType_SPECIFIC_DEPOSIT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollApplType_GENERAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollApplType_GENERAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollApplType_GENERAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollApplType_GENERAL));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingFXRateCalc_DIVIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingFXRateCalc_DIVIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingFXRateCalc_DIVIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::UnderlyingFXRateCalc_DIVIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingFXRateCalc_MULTIPLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingFXRateCalc_MULTIPLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingFXRateCalc_MULTIPLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::UnderlyingFXRateCalc_MULTIPLY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocPositionEffect_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocPositionEffect_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocPositionEffect_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocPositionEffect_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocPositionEffect_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocPositionEffect_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocPositionEffect_ROLLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocPositionEffect_ROLLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocPositionEffect_ROLLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_ROLLED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocPositionEffect_FIFO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocPositionEffect_FIFO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocPositionEffect_FIFO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_FIFO));
  return pyobj;
}


SWIGINTERN int Swig_var_DealingCapacity_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DealingCapacity_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DealingCapacity_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_AGENT));
  return pyobj;
}


SWIGINTERN int Swig_var_DealingCapacity_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DealingCapacity_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DealingCapacity_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DealingCapacity_RISKLESS_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DealingCapacity_RISKLESS_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DealingCapacity_RISKLESS_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_RISKLESS_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrmtAssignmentMethod_RANDOM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrmtAssignmentMethod_RANDOM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrmtAssignmentMethod_RANDOM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::InstrmtAssignmentMethod_RANDOM));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrmtAssignmentMethod_PRO_RATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrmtAssignmentMethod_PRO_RATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrmtAssignmentMethod_PRO_RATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::InstrmtAssignmentMethod_PRO_RATA));
  return pyobj;
}


SWIGINTERN int Swig_var_AggressorIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AggressorIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AggressorIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AggressorIndicator_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_AggressorIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AggressorIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AggressorIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AggressorIndicator_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_MDQuoteType_INDICATIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_INDICATIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDQuoteType_INDICATIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_INDICATIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDQuoteType_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDQuoteType_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_TRADEABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDQuoteType_RESTRICTED_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_RESTRICTED_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDQuoteType_RESTRICTED_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_RESTRICTED_TRADEABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDQuoteType_COUNTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_COUNTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDQuoteType_COUNTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_COUNTER));
  return pyobj;
}


SWIGINTERN int Swig_var_MDQuoteType_INDICATIVE_AND_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_INDICATIVE_AND_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDQuoteType_INDICATIVE_AND_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_INDICATIVE_AND_TRADEABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_SECONDARY_ORDER_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_SECONDARY_ORDER_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_SECONDARY_ORDER_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_SECONDARY_ORDER_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_ORDER_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_ORDER_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_ORDER_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_ORDER_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_MD_ENTRY_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_MD_ENTRY_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_MD_ENTRY_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_MD_ENTRY_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_QUOTE_ENTRY_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_QUOTE_ENTRY_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_QUOTE_ENTRY_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_QUOTE_ENTRY_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_ORIGINAL_ORDER_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_ORIGINAL_ORDER_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_ORIGINAL_ORDER_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_ORIGINAL_ORDER_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_QUOTE_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_QUOTE_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_QUOTE_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_QUOTE_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_QUOTE_REQ_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_QUOTE_REQ_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_QUOTE_REQ_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_QUOTE_REQ_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_PREVIOUS_ORDER_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_PREVIOUS_ORDER_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_PREVIOUS_ORDER_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_PREVIOUS_ORDER_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_PREVIOUS_QUOTE_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_PREVIOUS_QUOTE_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_PREVIOUS_QUOTE_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_PREVIOUS_QUOTE_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_PARENT_ORDER_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_PARENT_ORDER_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_PARENT_ORDER_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_PARENT_ORDER_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_MANUAL_ORDER_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_MANUAL_ORDER_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_MANUAL_ORDER_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_MANUAL_ORDER_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_DisplayWhen_IMMEDIATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayWhen_IMMEDIATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisplayWhen_IMMEDIATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayWhen_IMMEDIATE));
  return pyobj;
}


SWIGINTERN int Swig_var_DisplayWhen_EXHAUST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayWhen_EXHAUST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisplayWhen_EXHAUST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayWhen_EXHAUST));
  return pyobj;
}


SWIGINTERN int Swig_var_DisplayMethod_INITIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayMethod_INITIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisplayMethod_INITIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_INITIAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DisplayMethod_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayMethod_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisplayMethod_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_DisplayMethod_RANDOM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayMethod_RANDOM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisplayMethod_RANDOM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_RANDOM));
  return pyobj;
}


SWIGINTERN int Swig_var_DisplayMethod_UNDISCLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayMethod_UNDISCLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisplayMethod_UNDISCLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_UNDISCLOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceProtectionScope_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceProtectionScope_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceProtectionScope_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceProtectionScope_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceProtectionScope_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceProtectionScope_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_LOCAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceProtectionScope_NATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceProtectionScope_NATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceProtectionScope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_NATIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceProtectionScope_GLOBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceProtectionScope_GLOBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceProtectionScope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_GLOBAL));
  return pyobj;
}


SWIGINTERN int Swig_var_LotType_ODD_LOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LotType_ODD_LOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LotType_ODD_LOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LotType_ODD_LOT));
  return pyobj;
}


SWIGINTERN int Swig_var_LotType_ROUND_LOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LotType_ROUND_LOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LotType_ROUND_LOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LotType_ROUND_LOT));
  return pyobj;
}


SWIGINTERN int Swig_var_LotType_BLOCK_LOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LotType_BLOCK_LOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LotType_BLOCK_LOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LotType_BLOCK_LOT));
  return pyobj;
}


SWIGINTERN int Swig_var_LotType_ROUND_LOT_BASED_UPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LotType_ROUND_LOT_BASED_UPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LotType_ROUND_LOT_BASED_UPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LotType_ROUND_LOT_BASED_UPON));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_LAST_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_LAST_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_LAST_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_LAST_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_MID_PRICE_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_MID_PRICE_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_MID_PRICE_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_MID_PRICE_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_OPENING_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_OPENING_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_OPENING_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_OPENING_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_MARKET_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_MARKET_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_MARKET_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_MARKET_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_PRIMARY_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_PRIMARY_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_PRIMARY_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_PRIMARY_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_PEG_TO_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_PEG_TO_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_PEG_TO_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_PEG_TO_VWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_TRAILING_STOP_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_TRAILING_STOP_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_TRAILING_STOP_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_TRAILING_STOP_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_PEG_TO_LIMIT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_PEG_TO_LIMIT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_PEG_TO_LIMIT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_PEG_TO_LIMIT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_SHORT_SALE_MIN_PRICE_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_SHORT_SALE_MIN_PRICE_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_SHORT_SALE_MIN_PRICE_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_SHORT_SALE_MIN_PRICE_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerType_PARTIAL_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerType_PARTIAL_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerType_PARTIAL_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerType_PARTIAL_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerType_SPECIFIED_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerType_SPECIFIED_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerType_SPECIFIED_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerType_SPECIFIED_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerType_NEXT_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerType_NEXT_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerType_NEXT_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerType_NEXT_AUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerType_PRICE_MOVEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerType_PRICE_MOVEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerType_PRICE_MOVEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerType_PRICE_MOVEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerType_ON_ORDER_ENTRY_OR_MODIFICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerType_ON_ORDER_ENTRY_OR_MODIFICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerType_ON_ORDER_ENTRY_OR_MODIFICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerType_ON_ORDER_ENTRY_OR_MODIFICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerAction_ACTIVATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerAction_ACTIVATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerAction_ACTIVATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerAction_ACTIVATE));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerAction_MODIFY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerAction_MODIFY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerAction_MODIFY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerAction_MODIFY));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerAction_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerAction_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerAction_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerAction_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceType_BEST_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_BEST_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceType_BEST_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceType_LAST_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_LAST_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceType_LAST_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_LAST_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceType_BEST_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_BEST_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceType_BEST_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceType_BEST_BID_OR_LAST_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_BEST_BID_OR_LAST_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceType_BEST_BID_OR_LAST_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_BID_OR_LAST_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceType_BEST_OFFER_OR_LAST_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_BEST_OFFER_OR_LAST_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceType_BEST_OFFER_OR_LAST_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_OFFER_OR_LAST_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceType_BEST_MID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_BEST_MID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceType_BEST_MID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_MID));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceTypeScope_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceTypeScope_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceTypeScope_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceTypeScope_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceTypeScope_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceTypeScope_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_LOCAL));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceTypeScope_NATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceTypeScope_NATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceTypeScope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_NATIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceTypeScope_GLOBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceTypeScope_GLOBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceTypeScope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_GLOBAL));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceDirection_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceDirection_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceDirection_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceDirection_UP));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceDirection_DOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceDirection_DOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceDirection_DOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceDirection_DOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerOrderType_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerOrderType_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerOrderType_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerOrderType_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerOrderType_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerOrderType_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerOrderType_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerOrderType_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_PRIVATELY_NEGOTIATED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_PRIVATELY_NEGOTIATED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_PRIVATELY_NEGOTIATED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_PRIVATELY_NEGOTIATED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_MULTILEG_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_MULTILEG_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_MULTILEG_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_MULTILEG_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_LINKED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_LINKED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_LINKED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_LINKED_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_QUOTE_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_QUOTE_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_QUOTE_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_QUOTE_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_IMPLIED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_IMPLIED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_IMPLIED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_IMPLIED_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_CROSS_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_CROSS_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_CROSS_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_CROSS_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_STREAMING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_STREAMING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_STREAMING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_STREAMING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_INTERNAL_CROSS_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_INTERNAL_CROSS_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_INTERNAL_CROSS_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_INTERNAL_CROSS_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_TRADE_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_TRADE_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_TRADE_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_TRADE_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_TWO_PARTY_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_TWO_PARTY_REPORT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_ONE_PARTY_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_ONE_PARTY_REPORT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_THIRD_PTY_RPT_FOR_PASS_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_THIRD_PTY_RPT_FOR_PASS_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_THIRD_PTY_RPT_FOR_PASS_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_THIRD_PTY_RPT_FOR_PASS_THROUGH));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_AUTO_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_ONE_PARTY_REPORT_AUTO_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_AUTO_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_ONE_PARTY_REPORT_AUTO_MATCH));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestinationIDSource_BIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationIDSource_BIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestinationIDSource_BIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_BIC));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestinationIDSource_GENERAL_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationIDSource_GENERAL_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestinationIDSource_GENERAL_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_GENERAL_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestinationIDSource_PROPRIETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationIDSource_PROPRIETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestinationIDSource_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_PROPRIETARY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestinationIDSource_ISO_COUNTRY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationIDSource_ISO_COUNTRY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestinationIDSource_ISO_COUNTRY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_ISO_COUNTRY_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestinationIDSource_MIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationIDSource_MIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestinationIDSource_MIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_MIC));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationQtyType_AUTO_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_AUTO_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationQtyType_AUTO_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_AUTO_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationQtyType_NON_AUTO_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_NON_AUTO_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationQtyType_NON_AUTO_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_NON_AUTO_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationQtyType_FINAL_WILL_BE_EXERCISED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_FINAL_WILL_BE_EXERCISED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationQtyType_FINAL_WILL_BE_EXERCISED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_FINAL_WILL_BE_EXERCISED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationQtyType_CONTRARY_INTENTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_CONTRARY_INTENTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationQtyType_CONTRARY_INTENTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_CONTRARY_INTENTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationQtyType_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationQtyType_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_BILLION_CUBIC_FEET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_BILLION_CUBIC_FEET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_BILLION_CUBIC_FEET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_BILLION_CUBIC_FEET);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_MILLION_BARRELS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MILLION_BARRELS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_MILLION_BARRELS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MILLION_BARRELS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_ONE_MILLION_BTU_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_ONE_MILLION_BTU is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_ONE_MILLION_BTU_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_ONE_MILLION_BTU);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_MEGAWATT_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MEGAWATT_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_MEGAWATT_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MEGAWATT_HOURS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_BARRELS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_BARRELS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_BARRELS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_BARRELS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_BUSHELS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_BUSHELS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_BUSHELS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_BUSHELS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_POUNDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_POUNDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_POUNDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_POUNDS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_GALLONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_GALLONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_GALLONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_GALLONS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_TROY_OUNCES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_TROY_OUNCES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_TROY_OUNCES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_TROY_OUNCES);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_METRIC_TONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_METRIC_TONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_METRIC_TONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_METRIC_TONS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_TONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_TONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_TONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_TONS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_US_DOLLARS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_US_DOLLARS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_US_DOLLARS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_US_DOLLARS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_CUBIC_METERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_CUBIC_METERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_CUBIC_METERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_CUBIC_METERS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_GIGAJOULES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_GIGAJOULES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_GIGAJOULES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_GIGAJOULES);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_HEAT_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_HEAT_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_HEAT_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_HEAT_RATE);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_KILOWATT_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_KILOWATT_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_KILOWATT_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_KILOWATT_HOURS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_MEGA_HEAT_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MEGA_HEAT_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_MEGA_HEAT_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MEGA_HEAT_RATE);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_THERMS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_THERMS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_THERMS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_THERMS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_TONS_OF_CARBON_DIOXIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_TONS_OF_CARBON_DIOXIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_TONS_OF_CARBON_DIOXIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_TONS_OF_CARBON_DIOXIDE);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_ALLOWANCES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_ALLOWANCES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_ALLOWANCES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_ALLOWANCES);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_BOARD_FEET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_BOARD_FEET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_BOARD_FEET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_BOARD_FEET);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_CURRENCY);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_COOLING_DEGREE_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_COOLING_DEGREE_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_COOLING_DEGREE_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_COOLING_DEGREE_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_CERTIFIED_EMISSIONS_REDUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_CERTIFIED_EMISSIONS_REDUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_CERTIFIED_EMISSIONS_REDUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_CERTIFIED_EMISSIONS_REDUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_CRITICAL_PRECIP_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_CRITICAL_PRECIP_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_CRITICAL_PRECIP_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_CRITICAL_PRECIP_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_CLIMATE_RESERVE_TONNES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_CLIMATE_RESERVE_TONNES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_CLIMATE_RESERVE_TONNES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_CLIMATE_RESERVE_TONNES);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_HUNDREDWEIGHT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_HUNDREDWEIGHT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_HUNDREDWEIGHT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_HUNDREDWEIGHT);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_DRY_METRIC_TONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_DRY_METRIC_TONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_DRY_METRIC_TONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_DRY_METRIC_TONS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_ENV_ALLWNC_CERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_ENV_ALLWNC_CERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_ENV_ALLWNC_CERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_ENV_ALLWNC_CERT);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_ENVIRONMENTAL_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_ENVIRONMENTAL_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_ENVIRONMENTAL_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_ENVIRONMENTAL_CREDIT);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_ENVIRONMENTAL_OFFSET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_ENVIRONMENTAL_OFFSET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_ENVIRONMENTAL_OFFSET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_ENVIRONMENTAL_OFFSET);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_GRAMS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_GRAMS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_GRAMS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_GRAMS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_GROSS_TONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_GROSS_TONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_GROSS_TONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_GROSS_TONS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_HEATING_DEGREE_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_HEATING_DEGREE_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_HEATING_DEGREE_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_HEATING_DEGREE_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_INDEX_POINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_INDEX_POINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_INDEX_POINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_INDEX_POINT);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_KILOGRAMS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_KILOGRAMS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_KILOGRAMS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_KILOGRAMS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_KILOLITERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_KILOLITERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_KILOLITERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_KILOLITERS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_KILOWATT_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_KILOWATT_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_KILOWATT_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_KILOWATT_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_KILOWATT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_KILOWATT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_KILOWATT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_KILOWATT_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_KILOWATT_HOUR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_KILOWATT_HOUR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_KILOWATT_HOUR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_KILOWATT_HOUR);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_KILOWATT_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_KILOWATT_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_KILOWATT_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_KILOWATT_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_KILOWATT_MINUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_KILOWATT_MINUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_KILOWATT_MINUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_KILOWATT_MINUTE);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_LITERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_LITERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_LITERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_LITERS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_MEGAWATT_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MEGAWATT_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_MEGAWATT_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MEGAWATT_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_MEGAWATT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MEGAWATT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_MEGAWATT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MEGAWATT_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_MEGAWATT_HOUR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MEGAWATT_HOUR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_MEGAWATT_HOUR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MEGAWATT_HOUR);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_MEGAWATT_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MEGAWATT_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_MEGAWATT_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MEGAWATT_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_MEGAWATT_MINUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MEGAWATT_MINUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_MEGAWATT_MINUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MEGAWATT_MINUTE);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_PRINCIPAL_WITH_RELATION_TO_DEBT_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_PRINCIPAL_WITH_RELATION_TO_DEBT_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_PRINCIPAL_WITH_RELATION_TO_DEBT_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_PRINCIPAL_WITH_RELATION_TO_DEBT_INSTRUMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_ARE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_ARE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_ARE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_ARE);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_ACRE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_ACRE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_ACRE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_ACRE);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_CENTILITER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_CENTILITER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_CENTILITER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_CENTILITER);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_CENTIMETER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_CENTIMETER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_CENTIMETER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_CENTIMETER);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_DIESEL_GALLON_EQUIVALENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_DIESEL_GALLON_EQUIVALENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_DIESEL_GALLON_EQUIVALENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_DIESEL_GALLON_EQUIVALENT);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_FOOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_FOOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_FOOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_FOOT);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_GB_GALLON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_GB_GALLON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_GB_GALLON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_GB_GALLON);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_GASOLINE_GALLON_EQUIVALENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_GASOLINE_GALLON_EQUIVALENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_GASOLINE_GALLON_EQUIVALENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_GASOLINE_GALLON_EQUIVALENT);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_HECTARE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_HECTARE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_HECTARE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_HECTARE);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_INCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_INCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_INCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_INCH);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_KILOMETER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_KILOMETER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_KILOMETER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_KILOMETER);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_METER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_METER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_METER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_METER);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_MILE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MILE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_MILE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MILE);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_MILLILITER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MILLILITER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_MILLILITER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MILLILITER);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_MILLIMETER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MILLIMETER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_MILLIMETER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MILLIMETER);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_US_OUNCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_US_OUNCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_US_OUNCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_US_OUNCE);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_PIECE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_PIECE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_PIECE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_PIECE);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_US_PINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_US_PINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_US_PINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_US_PINT);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_GB_PINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_GB_PINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_GB_PINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_GB_PINT);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_US_QUART_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_US_QUART is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_US_QUART_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_US_QUART);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_GB_QUART_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_GB_QUART is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_GB_QUART_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_GB_QUART);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_SQUARE_CENTIMETER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_SQUARE_CENTIMETER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_SQUARE_CENTIMETER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_SQUARE_CENTIMETER);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_SQUARE_FOOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_SQUARE_FOOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_SQUARE_FOOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_SQUARE_FOOT);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_SQUARE_INCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_SQUARE_INCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_SQUARE_INCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_SQUARE_INCH);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_SQUARE_KILOMETER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_SQUARE_KILOMETER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_SQUARE_KILOMETER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_SQUARE_KILOMETER);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_SQUARE_METER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_SQUARE_METER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_SQUARE_METER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_SQUARE_METER);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_SQUARE_MILE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_SQUARE_MILE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_SQUARE_MILE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_SQUARE_MILE);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_SQUARE_MILLIMETER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_SQUARE_MILLIMETER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_SQUARE_MILLIMETER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_SQUARE_MILLIMETER);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_SQUARE_YARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_SQUARE_YARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_SQUARE_YARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_SQUARE_YARD);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_YARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_YARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_YARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_YARD);
  return pyobj;
}


SWIGINTERN int Swig_var_ImpliedMarketIndicator_NOT_IMPLIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ImpliedMarketIndicator_NOT_IMPLIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ImpliedMarketIndicator_NOT_IMPLIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_NOT_IMPLIED));
  return pyobj;
}


SWIGINTERN int Swig_var_ImpliedMarketIndicator_IMPLIED_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ImpliedMarketIndicator_IMPLIED_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ImpliedMarketIndicator_IMPLIED_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_IMPLIED_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_ImpliedMarketIndicator_IMPLIED_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ImpliedMarketIndicator_IMPLIED_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ImpliedMarketIndicator_IMPLIED_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_IMPLIED_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligMode_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligMode_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligMode_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlObligMode_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligMode_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligMode_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligMode_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlObligMode_FINAL));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligTransType_RESTATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligTransType_RESTATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligTransType_RESTATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_RESTATE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligSource_INSTRUCTIONS_OF_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligSource_INSTRUCTIONS_OF_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligSource_INSTRUCTIONS_OF_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligSource_INSTRUCTIONS_OF_BROKER));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligSource_INVESTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligSource_INVESTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligSource_INVESTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligSource_INVESTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligSource_BUYERS_SETTLEMENT_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligSource_BUYERS_SETTLEMENT_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligSource_BUYERS_SETTLEMENT_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligSource_BUYERS_SETTLEMENT_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligSource_SELLERS_SETTLEMENT_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligSource_SELLERS_SETTLEMENT_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligSource_SELLERS_SETTLEMENT_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligSource_SELLERS_SETTLEMENT_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_REMOVED_FROM_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_REMOVED_FROM_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_REMOVED_FROM_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_REMOVED_FROM_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_LOCKED_MARKET_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_LOCKED_MARKET_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_LOCKED_MARKET_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_LOCKED_MARKET_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_CROSS_MARKET_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_CROSS_MARKET_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_CROSS_MARKET_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_CROSS_MARKET_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_ACTIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_PrivateQuote_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PrivateQuote_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PrivateQuote_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PrivateQuote_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_PrivateQuote_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PrivateQuote_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PrivateQuote_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PrivateQuote_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_RespondentType_ALL_MARKET_PARTICIPANTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RespondentType_ALL_MARKET_PARTICIPANTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RespondentType_ALL_MARKET_PARTICIPANTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RespondentType_ALL_MARKET_PARTICIPANTS));
  return pyobj;
}


SWIGINTERN int Swig_var_RespondentType_SPECIFIED_MARKET_PARTICIPANTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RespondentType_SPECIFIED_MARKET_PARTICIPANTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RespondentType_SPECIFIED_MARKET_PARTICIPANTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RespondentType_SPECIFIED_MARKET_PARTICIPANTS));
  return pyobj;
}


SWIGINTERN int Swig_var_RespondentType_ALL_MARKET_MAKERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RespondentType_ALL_MARKET_MAKERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RespondentType_ALL_MARKET_MAKERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RespondentType_ALL_MARKET_MAKERS));
  return pyobj;
}


SWIGINTERN int Swig_var_RespondentType_PRIMARY_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RespondentType_PRIMARY_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RespondentType_PRIMARY_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RespondentType_PRIMARY_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_ORDER_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_ORDER_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_ORDER_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_ORDER_IMBALANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_TRADING_RESUMES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_TRADING_RESUMES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_TRADING_RESUMES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_TRADING_RESUMES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_CHANGE_OF_BOOK_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_BOOK_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_CHANGE_OF_BOOK_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_BOOK_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_CORPORATE_ACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CORPORATE_ACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_CORPORATE_ACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CORPORATE_ACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_StatsType_EXCHANGE_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatsType_EXCHANGE_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatsType_EXCHANGE_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatsType_EXCHANGE_LAST));
  return pyobj;
}


SWIGINTERN int Swig_var_StatsType_HIGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatsType_HIGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatsType_HIGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatsType_HIGH));
  return pyobj;
}


SWIGINTERN int Swig_var_StatsType_AVERAGE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatsType_AVERAGE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatsType_AVERAGE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatsType_AVERAGE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_StatsType_TURNOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatsType_TURNOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatsType_TURNOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatsType_TURNOVER));
  return pyobj;
}


SWIGINTERN int Swig_var_MDSecSizeType_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDSecSizeType_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDSecSizeType_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDSecSizeType_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_MDSecSizeType_CUSTOMER_PROFESSIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDSecSizeType_CUSTOMER_PROFESSIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDSecSizeType_CUSTOMER_PROFESSIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDSecSizeType_CUSTOMER_PROFESSIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_MDSecSizeType_DO_NOT_TRADE_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDSecSizeType_DO_NOT_TRADE_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDSecSizeType_DO_NOT_TRADE_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDSecSizeType_DO_NOT_TRADE_THROUGH));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlMethod_CASH_SETTLEMENT_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlMethod_CASH_SETTLEMENT_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlMethod_CASH_SETTLEMENT_REQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlMethod_CASH_SETTLEMENT_REQUIRED);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlMethod_ELECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlMethod_ELECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlMethod_ELECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlMethod_ELECTION);
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseStyle_EUROPEAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseStyle_EUROPEAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseStyle_EUROPEAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_EUROPEAN));
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseStyle_AMERICAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseStyle_AMERICAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseStyle_AMERICAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_AMERICAN));
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseStyle_BERMUDA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseStyle_BERMUDA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseStyle_BERMUDA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_BERMUDA));
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseStyle_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseStyle_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseStyle_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceQuoteMethod_STANDARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQuoteMethod_STANDARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceQuoteMethod_STANDARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PriceQuoteMethod_STANDARD);
  return pyobj;
}


SWIGINTERN int Swig_var_PriceQuoteMethod_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQuoteMethod_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceQuoteMethod_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PriceQuoteMethod_INDEX);
  return pyobj;
}


SWIGINTERN int Swig_var_PriceQuoteMethod_INTEREST_RATE_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQuoteMethod_INTEREST_RATE_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceQuoteMethod_INTEREST_RATE_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PriceQuoteMethod_INTEREST_RATE_INDEX);
  return pyobj;
}


SWIGINTERN int Swig_var_PriceQuoteMethod_PERCENT_OF_PAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQuoteMethod_PERCENT_OF_PAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceQuoteMethod_PERCENT_OF_PAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PriceQuoteMethod_PERCENT_OF_PAR);
  return pyobj;
}


SWIGINTERN int Swig_var_FuturesValuationMethod_PREMIUM_STYLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FuturesValuationMethod_PREMIUM_STYLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FuturesValuationMethod_PREMIUM_STYLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FuturesValuationMethod_PREMIUM_STYLE);
  return pyobj;
}


SWIGINTERN int Swig_var_FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET);
  return pyobj;
}


SWIGINTERN int Swig_var_FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_ListMethod_PRE_LISTED_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListMethod_PRE_LISTED_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListMethod_PRE_LISTED_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListMethod_PRE_LISTED_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_ListMethod_USER_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListMethod_USER_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListMethod_USER_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListMethod_USER_REQUESTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TickRuleType_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickRuleType_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_REGULAR));
  return pyobj;
}


SWIGINTERN int Swig_var_TickRuleType_VARIABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_VARIABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickRuleType_VARIABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_VARIABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_TickRuleType_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickRuleType_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_FIXED));
  return pyobj;
}


SWIGINTERN int Swig_var_TickRuleType_TRADED_AS_A_SPREAD_LEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_TRADED_AS_A_SPREAD_LEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickRuleType_TRADED_AS_A_SPREAD_LEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_TRADED_AS_A_SPREAD_LEG));
  return pyobj;
}


SWIGINTERN int Swig_var_TickRuleType_SETTLED_AS_A_SPREAD_LEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_SETTLED_AS_A_SPREAD_LEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickRuleType_SETTLED_AS_A_SPREAD_LEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_SETTLED_AS_A_SPREAD_LEG));
  return pyobj;
}


SWIGINTERN int Swig_var_TickRuleType_REGULAR_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_REGULAR_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickRuleType_REGULAR_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_REGULAR_TRADING));
  return pyobj;
}


SWIGINTERN int Swig_var_TickRuleType_VARIABLE_CABINET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_VARIABLE_CABINET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickRuleType_VARIABLE_CABINET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_VARIABLE_CABINET));
  return pyobj;
}


SWIGINTERN int Swig_var_TickRuleType_FIXED_CABINET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_FIXED_CABINET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickRuleType_FIXED_CABINET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_FIXED_CABINET));
  return pyobj;
}


SWIGINTERN int Swig_var_TickRuleType_TRADED_AS_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_TRADED_AS_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickRuleType_TRADED_AS_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_TRADED_AS_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_MaturityMonthYearIncrementUnits_MONTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearIncrementUnits_MONTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MaturityMonthYearIncrementUnits_MONTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_MONTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_MaturityMonthYearIncrementUnits_DAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearIncrementUnits_DAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MaturityMonthYearIncrementUnits_DAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_DAYS));
  return pyobj;
}


SWIGINTERN int Swig_var_MaturityMonthYearIncrementUnits_WEEKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearIncrementUnits_WEEKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MaturityMonthYearIncrementUnits_WEEKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_WEEKS));
  return pyobj;
}


SWIGINTERN int Swig_var_MaturityMonthYearIncrementUnits_YEARS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearIncrementUnits_YEARS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MaturityMonthYearIncrementUnits_YEARS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_YEARS));
  return pyobj;
}


SWIGINTERN int Swig_var_MaturityMonthYearFormat_YEAR_MONTH_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearFormat_YEAR_MONTH_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MaturityMonthYearFormat_YEAR_MONTH_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEAR_MONTH_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_MaturityMonthYearFormat_YEAR_MONTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearFormat_YEAR_MONTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MaturityMonthYearFormat_YEAR_MONTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEAR_MONTH_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_MaturityMonthYearFormat_YEAR_MONTH_WEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearFormat_YEAR_MONTH_WEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MaturityMonthYearFormat_YEAR_MONTH_WEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEAR_MONTH_WEEK));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceLimitType_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceLimitType_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceLimitType_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceLimitType_TICKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceLimitType_TICKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceLimitType_TICKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_TICKS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceLimitType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceLimitType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceLimitType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_ListUpdateAction_ADD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListUpdateAction_ADD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListUpdateAction_ADD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListUpdateAction_ADD));
  return pyobj;
}


SWIGINTERN int Swig_var_ListUpdateAction_DELETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListUpdateAction_DELETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListUpdateAction_DELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListUpdateAction_DELETE));
  return pyobj;
}


SWIGINTERN int Swig_var_ListUpdateAction_MODIFY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListUpdateAction_MODIFY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListUpdateAction_MODIFY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListUpdateAction_MODIFY));
  return pyobj;
}


SWIGINTERN int Swig_var_ListUpdateAction_SNAPSHOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListUpdateAction_SNAPSHOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListUpdateAction_SNAPSHOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListUpdateAction_SNAPSHOT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketUpdateAction_ADD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketUpdateAction_ADD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketUpdateAction_ADD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_ADD));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketUpdateAction_DELETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketUpdateAction_DELETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketUpdateAction_DELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_DELETE));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketUpdateAction_MODIFY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketUpdateAction_MODIFY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketUpdateAction_MODIFY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_MODIFY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesEvent_TRADING_RESUMES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesEvent_TRADING_RESUMES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesEvent_TRADING_RESUMES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesEvent_TRADING_RESUMES));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesEvent_CHANGE_OF_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesEvent_CHANGE_OF_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesEvent_CHANGE_OF_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesEvent_CHANGE_OF_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesEvent_CHANGE_OF_TRADING_SUBSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesEvent_CHANGE_OF_TRADING_SUBSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesEvent_CHANGE_OF_TRADING_SUBSESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesEvent_CHANGE_OF_TRADING_SUBSESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesEvent_CHANGE_OF_TRADING_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesEvent_CHANGE_OF_TRADING_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesEvent_CHANGE_OF_TRADING_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesEvent_CHANGE_OF_TRADING_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionType_SUSPEND_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionType_SUSPEND_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionType_SUSPEND_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionType_SUSPEND_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionType_RELEASE_ORDERS_FROM_SUSPENSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionType_RELEASE_ORDERS_FROM_SUSPENSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionType_RELEASE_ORDERS_FROM_SUSPENSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionType_RELEASE_ORDERS_FROM_SUSPENSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionType_CANCEL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionType_CANCEL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionType_CANCEL_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionType_CANCEL_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_ACFI_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_ACFI_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_ACFI_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_ACFI_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_SECURITY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_CANCEL_FOR_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_CANCEL_FOR_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_CANCEL_FOR_SECURITY_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_CANCEL_FOR_SECURITY_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionResponse_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionResponse_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionResponse_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionResponse_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionResponse_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionResponse_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionResponse_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionResponse_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionResponse_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionResponse_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionResponse_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionResponse_COMPLETED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_CFI_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_CFI_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_CFI_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_CFI_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegModel_PREDEFINED_MULTILEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegModel_PREDEFINED_MULTILEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegModel_PREDEFINED_MULTILEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegModel_PREDEFINED_MULTILEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegModel_USER_DEFINED_MULTILEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegModel_USER_DEFINED_MULTILEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegModel_USER_DEFINED_MULTILEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegModel_USER_DEFINED_MULTILEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegModel_USER_DEFINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegModel_USER_DEFINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegModel_USER_DEFINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegModel_USER_DEFINED));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegPriceMethod_NET_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegPriceMethod_NET_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegPriceMethod_NET_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_NET_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegPriceMethod_REVERSED_NET_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegPriceMethod_REVERSED_NET_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegPriceMethod_REVERSED_NET_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_REVERSED_NET_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegPriceMethod_YIELD_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegPriceMethod_YIELD_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegPriceMethod_YIELD_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_YIELD_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegPriceMethod_INDIVIDUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegPriceMethod_INDIVIDUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegPriceMethod_INDIVIDUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_INDIVIDUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegPriceMethod_MULTIPLIED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegPriceMethod_MULTIPLIED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegPriceMethod_MULTIPLIED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_MULTIPLIED_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ContingencyType_ONE_CANCELS_THE_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContingencyType_ONE_CANCELS_THE_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContingencyType_ONE_CANCELS_THE_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContingencyType_ONE_CANCELS_THE_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_ContingencyType_ONE_TRIGGERS_THE_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContingencyType_ONE_TRIGGERS_THE_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContingencyType_ONE_TRIGGERS_THE_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContingencyType_ONE_TRIGGERS_THE_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_ABSOLUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContingencyType_ONE_UPDATES_THE_OTHER_ABSOLUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_ABSOLUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContingencyType_ONE_UPDATES_THE_OTHER_ABSOLUTE));
  return pyobj;
}


SWIGINTERN int Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_PROPORTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContingencyType_ONE_UPDATES_THE_OTHER_PROPORTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_PROPORTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContingencyType_ONE_UPDATES_THE_OTHER_PROPORTIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_ContingencyType_BID_AND_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContingencyType_BID_AND_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContingencyType_BID_AND_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContingencyType_BID_AND_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_ContingencyType_BID_AND_OFFER_OCO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContingencyType_BID_AND_OFFER_OCO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContingencyType_BID_AND_OFFER_OCO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContingencyType_BID_AND_OFFER_OCO));
  return pyobj;
}


SWIGINTERN int Swig_var_ListRejectReason_BROKER_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_BROKER_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListRejectReason_BROKER_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_BROKER_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_ListRejectReason_EXCHANGE_CLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_EXCHANGE_CLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListRejectReason_EXCHANGE_CLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_EXCHANGE_CLOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_ListRejectReason_TOO_LATE_TO_ENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_TOO_LATE_TO_ENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListRejectReason_TOO_LATE_TO_ENTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_TOO_LATE_TO_ENTER));
  return pyobj;
}


SWIGINTERN int Swig_var_ListRejectReason_UNKNOWN_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_UNKNOWN_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListRejectReason_UNKNOWN_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_UNKNOWN_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_ListRejectReason_DUPLICATE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_DUPLICATE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListRejectReason_DUPLICATE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_DUPLICATE_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC));
  return pyobj;
}


SWIGINTERN int Swig_var_ListRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePublishIndicator_DO_NOT_PUBLISH_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePublishIndicator_DO_NOT_PUBLISH_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePublishIndicator_DO_NOT_PUBLISH_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePublishIndicator_DO_NOT_PUBLISH_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePublishIndicator_PUBLISH_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePublishIndicator_PUBLISH_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePublishIndicator_PUBLISH_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePublishIndicator_PUBLISH_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePublishIndicator_DEFERRED_PUBLICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePublishIndicator_DEFERRED_PUBLICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePublishIndicator_DEFERRED_PUBLICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePublishIndicator_DEFERRED_PUBLICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePublishIndicator_PUBLISHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePublishIndicator_PUBLISHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePublishIndicator_PUBLISHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePublishIndicator_PUBLISHED));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReqType_RETRANSMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_RETRANSMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReqType_RETRANSMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_RETRANSMISSION));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReqType_SUBSCRIPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_SUBSCRIPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReqType_SUBSCRIPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_SUBSCRIPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReqType_REQUEST_LAST_SEQ_NUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_REQUEST_LAST_SEQ_NUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReqType_REQUEST_LAST_SEQ_NUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_REQUEST_LAST_SEQ_NUM));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReqType_REQUEST_APPLICATIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_REQUEST_APPLICATIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReqType_REQUEST_APPLICATIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_REQUEST_APPLICATIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReqType_UNSUBSCRIBE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_UNSUBSCRIBE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReqType_UNSUBSCRIBE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_UNSUBSCRIBE));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReqType_CANCEL_RETRANSMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_CANCEL_RETRANSMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReqType_CANCEL_RETRANSMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_CANCEL_RETRANSMISSION));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReqType_CANCEL_RETRANSMISSION_UNSUBSCRIBE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_CANCEL_RETRANSMISSION_UNSUBSCRIBE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReqType_CANCEL_RETRANSMISSION_UNSUBSCRIBE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_CANCEL_RETRANSMISSION_UNSUBSCRIBE));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplResponseType_APPLICATION_DOES_NOT_EXIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseType_APPLICATION_DOES_NOT_EXIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplResponseType_APPLICATION_DOES_NOT_EXIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplResponseType_APPLICATION_DOES_NOT_EXIST));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplResponseType_MESSAGES_NOT_AVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseType_MESSAGES_NOT_AVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplResponseType_MESSAGES_NOT_AVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplResponseType_MESSAGES_NOT_AVAILABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplResponseError_APPLICATION_DOES_NOT_EXIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseError_APPLICATION_DOES_NOT_EXIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplResponseError_APPLICATION_DOES_NOT_EXIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplResponseError_APPLICATION_DOES_NOT_EXIST));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReportType_APPL_SEQ_NUM_RESET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReportType_APPL_SEQ_NUM_RESET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReportType_APPL_SEQ_NUM_RESET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReportType_APPL_SEQ_NUM_RESET));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReportType_LAST_MESSAGE_SENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReportType_LAST_MESSAGE_SENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReportType_LAST_MESSAGE_SENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReportType_LAST_MESSAGE_SENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReportType_APPLICATION_ALIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReportType_APPLICATION_ALIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReportType_APPLICATION_ALIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReportType_APPLICATION_ALIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReportType_RESEND_COMPLETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReportType_RESEND_COMPLETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReportType_RESEND_COMPLETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReportType_RESEND_COMPLETE));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonInt_NEWS_DISSEMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonInt_NEWS_DISSEMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonInt_NEWS_DISSEMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_NEWS_DISSEMINATION));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonInt_ORDER_INFLUX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonInt_ORDER_INFLUX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonInt_ORDER_INFLUX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ORDER_INFLUX));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonInt_ORDER_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonInt_ORDER_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonInt_ORDER_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ORDER_IMBALANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonInt_ADDITIONAL_INFORMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonInt_ADDITIONAL_INFORMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonInt_ADDITIONAL_INFORMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ADDITIONAL_INFORMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonInt_NEWS_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonInt_NEWS_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonInt_NEWS_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_NEWS_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonInt_EQUIPMENT_CHANGEOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonInt_EQUIPMENT_CHANGEOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonInt_EQUIPMENT_CHANGEOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_EQUIPMENT_CHANGEOVER));
  return pyobj;
}


SWIGINTERN int Swig_var_ValuationMethod_PREMIUM_STYLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValuationMethod_PREMIUM_STYLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValuationMethod_PREMIUM_STYLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ValuationMethod_PREMIUM_STYLE);
  return pyobj;
}


SWIGINTERN int Swig_var_ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET);
  return pyobj;
}


SWIGINTERN int Swig_var_ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_ValuationMethod_CDS_STYLE_COLLATERALIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValuationMethod_CDS_STYLE_COLLATERALIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValuationMethod_CDS_STYLE_COLLATERALIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ValuationMethod_CDS_STYLE_COLLATERALIZATION);
  return pyobj;
}


SWIGINTERN int Swig_var_ValuationMethod_CDS_IN_DELIVERY_USE_RECOVERY_RATE_TO_CALCULATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValuationMethod_CDS_IN_DELIVERY_USE_RECOVERY_RATE_TO_CALCULATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValuationMethod_CDS_IN_DELIVERY_USE_RECOVERY_RATE_TO_CALCULATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ValuationMethod_CDS_IN_DELIVERY_USE_RECOVERY_RATE_TO_CALCULATE);
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_SECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_SECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_SECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_SECONDS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_TENTHS_OF_A_SECOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_TENTHS_OF_A_SECOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_TENTHS_OF_A_SECOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_TENTHS_OF_A_SECOND));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_HUNDREDTHS_OF_A_SECOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_HUNDREDTHS_OF_A_SECOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_HUNDREDTHS_OF_A_SECOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_HUNDREDTHS_OF_A_SECOND));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_MILLISECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_MILLISECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_MILLISECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MILLISECONDS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_MICROSECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_MICROSECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_MICROSECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MICROSECONDS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_NANOSECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_NANOSECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_NANOSECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_NANOSECONDS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_MINUTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_MINUTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_MINUTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MINUTES));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_HOURS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_DAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_DAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_DAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_DAYS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_WEEKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_WEEKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_WEEKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_WEEKS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_MONTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_MONTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_MONTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MONTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_YEARS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_YEARS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_YEARS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_YEARS));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_ELECTRONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_ELECTRONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_ELECTRONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_ELECTRONIC));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_PIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_PIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_PIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_PIT));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_EX_PIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_EX_PIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_EX_PIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_EX_PIT));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_CLEARING_HOUSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_CLEARING_HOUSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_CLEARING_HOUSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_CLEARING_HOUSE));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_REGISTERED_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_REGISTERED_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_REGISTERED_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_REGISTERED_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_OFF_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_OFF_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_OFF_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_OFF_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_CENTRAL_LIMIT_ORDER_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_CENTRAL_LIMIT_ORDER_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_CENTRAL_LIMIT_ORDER_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_CENTRAL_LIMIT_ORDER_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_QUOTE_DRIVEN_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_QUOTE_DRIVEN_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_QUOTE_DRIVEN_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_QUOTE_DRIVEN_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_DARK_ORDER_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_DARK_ORDER_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_DARK_ORDER_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_DARK_ORDER_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_AUCTION_DRIVEN_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_AUCTION_DRIVEN_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_AUCTION_DRIVEN_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_AUCTION_DRIVEN_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_QUOTE_NEGOTIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_QUOTE_NEGOTIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_QUOTE_NEGOTIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_QUOTE_NEGOTIATION));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_VOICE_NEGOTIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_VOICE_NEGOTIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_VOICE_NEGOTIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_VOICE_NEGOTIATION));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_HYBRID_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_HYBRID_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_HYBRID_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_HYBRID_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_OTHER_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_OTHER_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_OTHER_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_OTHER_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrdIDReason_GTC_FROM_PREVIOUS_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrdIDReason_GTC_FROM_PREVIOUS_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrdIDReason_GTC_FROM_PREVIOUS_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RefOrdIDReason_GTC_FROM_PREVIOUS_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrdIDReason_PARTIAL_FILL_REMAINING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrdIDReason_PARTIAL_FILL_REMAINING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrdIDReason_PARTIAL_FILL_REMAINING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RefOrdIDReason_PARTIAL_FILL_REMAINING));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrdIDReason_ORDER_CHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrdIDReason_ORDER_CHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrdIDReason_ORDER_CHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RefOrdIDReason_ORDER_CHANGED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrigCustOrderCapacity_ALL_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrigCustOrderCapacity_ALL_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrigCustOrderCapacity_ALL_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrigCustOrderCapacity_ALL_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_ModelType_UTILITY_PROVIDED_STANDARD_MODEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ModelType_UTILITY_PROVIDED_STANDARD_MODEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ModelType_UTILITY_PROVIDED_STANDARD_MODEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ModelType_UTILITY_PROVIDED_STANDARD_MODEL));
  return pyobj;
}


SWIGINTERN int Swig_var_ModelType_PROPRIETARY_MODEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ModelType_PROPRIETARY_MODEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ModelType_PROPRIETARY_MODEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ModelType_PROPRIETARY_MODEL));
  return pyobj;
}


SWIGINTERN int Swig_var_ContractMultiplierUnit_SHARES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContractMultiplierUnit_SHARES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContractMultiplierUnit_SHARES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_SHARES));
  return pyobj;
}


SWIGINTERN int Swig_var_ContractMultiplierUnit_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContractMultiplierUnit_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContractMultiplierUnit_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_HOURS));
  return pyobj;
}


SWIGINTERN int Swig_var_ContractMultiplierUnit_DAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContractMultiplierUnit_DAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContractMultiplierUnit_DAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_DAYS));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_NERC_EASTERN_OFF_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_NERC_EASTERN_OFF_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_NERC_EASTERN_OFF_PEAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_EASTERN_OFF_PEAK));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_NERC_WESTERN_OFF_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_NERC_WESTERN_OFF_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_NERC_WESTERN_OFF_PEAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_WESTERN_OFF_PEAK));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_NERC_EASTERN_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_NERC_EASTERN_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_NERC_EASTERN_PEAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_EASTERN_PEAK));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_NERC_WESTERN_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_NERC_WESTERN_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_NERC_WESTERN_PEAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_WESTERN_PEAK));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_ALL_TIMES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_ALL_TIMES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_ALL_TIMES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_ALL_TIMES));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_ON_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_ON_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_ON_PEAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_ON_PEAK));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_OFF_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_OFF_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_OFF_PEAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_OFF_PEAK));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_BASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_BASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_BASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_BASE));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_BLOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_BLOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_BLOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_BLOCK));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_RateSource_BLOOMBERG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSource_BLOOMBERG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RateSource_BLOOMBERG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSource_BLOOMBERG));
  return pyobj;
}


SWIGINTERN int Swig_var_RateSource_REUTERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSource_REUTERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RateSource_REUTERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSource_REUTERS));
  return pyobj;
}


SWIGINTERN int Swig_var_RateSource_TELERATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSource_TELERATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RateSource_TELERATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSource_TELERATE));
  return pyobj;
}


SWIGINTERN int Swig_var_RateSource_ISDA_RATE_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSource_ISDA_RATE_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RateSource_ISDA_RATE_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSource_ISDA_RATE_OPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_RateSource_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSource_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RateSource_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSource_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_RateSourceType_PRIMARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSourceType_PRIMARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RateSourceType_PRIMARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSourceType_PRIMARY));
  return pyobj;
}


SWIGINTERN int Swig_var_RateSourceType_SECONDARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSourceType_SECONDARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RateSourceType_SECONDARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSourceType_SECONDARY));
  return pyobj;
}


SWIGINTERN int Swig_var_RestructuringType_FULL_RESTRUCTURING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RestructuringType_FULL_RESTRUCTURING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RestructuringType_FULL_RESTRUCTURING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RestructuringType_FULL_RESTRUCTURING);
  return pyobj;
}


SWIGINTERN int Swig_var_RestructuringType_MODIFIED_RESTRUCTURING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RestructuringType_MODIFIED_RESTRUCTURING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RestructuringType_MODIFIED_RESTRUCTURING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RestructuringType_MODIFIED_RESTRUCTURING);
  return pyobj;
}


SWIGINTERN int Swig_var_RestructuringType_MODIFIED_MOD_RESTRUCTURING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RestructuringType_MODIFIED_MOD_RESTRUCTURING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RestructuringType_MODIFIED_MOD_RESTRUCTURING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RestructuringType_MODIFIED_MOD_RESTRUCTURING);
  return pyobj;
}


SWIGINTERN int Swig_var_RestructuringType_NO_RESTRUCTURING_SPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RestructuringType_NO_RESTRUCTURING_SPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RestructuringType_NO_RESTRUCTURING_SPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RestructuringType_NO_RESTRUCTURING_SPECIFIED);
  return pyobj;
}


SWIGINTERN int Swig_var_Seniority_SENIOR_SECURED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Seniority_SENIOR_SECURED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Seniority_SENIOR_SECURED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::Seniority_SENIOR_SECURED);
  return pyobj;
}


SWIGINTERN int Swig_var_Seniority_SENIOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Seniority_SENIOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Seniority_SENIOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::Seniority_SENIOR);
  return pyobj;
}


SWIGINTERN int Swig_var_Seniority_SUBORDINATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Seniority_SUBORDINATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Seniority_SUBORDINATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::Seniority_SUBORDINATED);
  return pyobj;
}


SWIGINTERN int Swig_var_Seniority_JUNIOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Seniority_JUNIOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Seniority_JUNIOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::Seniority_JUNIOR);
  return pyobj;
}


SWIGINTERN int Swig_var_Seniority_MEZZANINE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Seniority_MEZZANINE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Seniority_MEZZANINE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::Seniority_MEZZANINE);
  return pyobj;
}


SWIGINTERN int Swig_var_Seniority_SENIOR_NON_PREFERRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Seniority_SENIOR_NON_PREFERRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Seniority_SENIOR_NON_PREFERRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::Seniority_SENIOR_NON_PREFERRED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListType_INDUSTRY_CLASSIFICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListType_INDUSTRY_CLASSIFICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListType_INDUSTRY_CLASSIFICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListType_INDUSTRY_CLASSIFICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListType_TRADING_LIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListType_TRADING_LIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListType_TRADING_LIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListType_TRADING_LIST));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListType_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListType_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListType_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListType_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListType_NEWSPAPER_LIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListType_NEWSPAPER_LIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListType_NEWSPAPER_LIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListType_NEWSPAPER_LIST));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListTypeSource_ICB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListTypeSource_ICB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListTypeSource_ICB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_ICB));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListTypeSource_NAICS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListTypeSource_NAICS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListTypeSource_NAICS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_NAICS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListTypeSource_GICS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListTypeSource_GICS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListTypeSource_GICS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_GICS));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsCategory_COMPANY_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_COMPANY_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsCategory_COMPANY_NEWS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsCategory_COMPANY_NEWS));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsCategory_MARKETPLACE_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_MARKETPLACE_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsCategory_MARKETPLACE_NEWS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsCategory_MARKETPLACE_NEWS));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsCategory_FINANCIAL_MARKET_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_FINANCIAL_MARKET_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsCategory_FINANCIAL_MARKET_NEWS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsCategory_FINANCIAL_MARKET_NEWS));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsCategory_TECHNICAL_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_TECHNICAL_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsCategory_TECHNICAL_NEWS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsCategory_TECHNICAL_NEWS));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsCategory_OTHER_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_OTHER_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsCategory_OTHER_NEWS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsCategory_OTHER_NEWS));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsRefType_REPLACEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsRefType_REPLACEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsRefType_REPLACEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsRefType_REPLACEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsRefType_OTHER_LANGUAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsRefType_OTHER_LANGUAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsRefType_OTHER_LANGUAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsRefType_OTHER_LANGUAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsRefType_COMPLIMENTARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsRefType_COMPLIMENTARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsRefType_COMPLIMENTARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsRefType_COMPLIMENTARY));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsRefType_WITHDRAWAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsRefType_WITHDRAWAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsRefType_WITHDRAWAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsRefType_WITHDRAWAL));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceDeterminationMethod_FIXED_STRIKE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceDeterminationMethod_FIXED_STRIKE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceDeterminationMethod_FIXED_STRIKE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceDeterminationMethod_FIXED_STRIKE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_ACROSS_LIFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_ACROSS_LIFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_ACROSS_LIFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_ACROSS_LIFE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceBoundaryMethod_LESS_THAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceBoundaryMethod_LESS_THAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceBoundaryMethod_LESS_THAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_LESS_THAN));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceBoundaryMethod_EQUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceBoundaryMethod_EQUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceBoundaryMethod_EQUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_EQUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceBoundaryMethod_GREATER_THAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_GREATER_THAN));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingPriceDeterminationMethod_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingPriceDeterminationMethod_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingPriceDeterminationMethod_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_REGULAR));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingPriceDeterminationMethod_AVERAGE_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_AVERAGE_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_OptPayoutType_VANILLA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_VANILLA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OptPayoutType_VANILLA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_VANILLA));
  return pyobj;
}


SWIGINTERN int Swig_var_OptPayoutType_CAPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_CAPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OptPayoutType_CAPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_CAPPED));
  return pyobj;
}


SWIGINTERN int Swig_var_OptPayoutType_BINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_BINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OptPayoutType_BINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_BINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_OptPayoutType_ASIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_ASIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OptPayoutType_ASIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_ASIAN));
  return pyobj;
}


SWIGINTERN int Swig_var_OptPayoutType_BARRIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_BARRIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OptPayoutType_BARRIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_BARRIER));
  return pyobj;
}


SWIGINTERN int Swig_var_OptPayoutType_DIGITAL_BARRIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_DIGITAL_BARRIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OptPayoutType_DIGITAL_BARRIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_DIGITAL_BARRIER));
  return pyobj;
}


SWIGINTERN int Swig_var_OptPayoutType_LOOKBACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_LOOKBACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OptPayoutType_LOOKBACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_LOOKBACK));
  return pyobj;
}


SWIGINTERN int Swig_var_OptPayoutType_OTHER_PATH_DEPENDENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_OTHER_PATH_DEPENDENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OptPayoutType_OTHER_PATH_DEPENDENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_OTHER_PATH_DEPENDENT));
  return pyobj;
}


SWIGINTERN int Swig_var_OptPayoutType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OptPayoutType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_CAPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_CAPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_CAPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_CAPPED));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_TRIGGER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_TRIGGER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_TRIGGER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_TRIGGER));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_KNOCK_IN_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_KNOCK_IN_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_KNOCK_IN_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_KNOCK_IN_UP));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_KNOCK_IN_DOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_KNOCK_IN_DOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_KNOCK_IN_DOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_KNOCK_IN_DOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_KNOCK_OUT_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_KNOCK_OUT_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_KNOCK_OUT_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_KNOCK_OUT_UP));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_KNOCK_OUT_DOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_KNOCK_OUT_DOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_KNOCK_OUT_DOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_KNOCK_OUT_DOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_UNDERLYING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_UNDERLYING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_UNDERLYING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_UNDERLYING));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_RESET_BARRIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_RESET_BARRIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_RESET_BARRIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_RESET_BARRIER));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_ROLLING_BARRIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_ROLLING_BARRIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_ROLLING_BARRIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_ROLLING_BARRIER));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_ONE_TOUCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_ONE_TOUCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_ONE_TOUCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_ONE_TOUCH));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_NO_TOUCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_NO_TOUCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_NO_TOUCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_NO_TOUCH));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_DBL_ONE_TOUCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_DBL_ONE_TOUCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_DBL_ONE_TOUCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_DBL_ONE_TOUCH));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_DBL_NO_TOUCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_DBL_NO_TOUCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_DBL_NO_TOUCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_DBL_NO_TOUCH));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_FX_COMPOSITE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_FX_COMPOSITE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_FX_COMPOSITE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_FX_COMPOSITE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_FX_QUANTO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_FX_QUANTO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_FX_QUANTO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_FX_QUANTO));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_FX_CRSS_CCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_FX_CRSS_CCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_FX_CRSS_CCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_FX_CRSS_CCY));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_STRK_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_STRK_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_STRK_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_STRK_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_CLNDR_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_CLNDR_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_CLNDR_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_CLNDR_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_PX_OBSVTN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_PX_OBSVTN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_PX_OBSVTN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_PX_OBSVTN));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_PASS_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_PASS_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_PASS_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_PASS_THROUGH));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_STRK_SCHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_STRK_SCHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_STRK_SCHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_STRK_SCHED));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_EQUITY_VALUATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_EQUITY_VALUATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_EQUITY_VALUATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_EQUITY_VALUATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_DIVIDEND_VALUATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_DIVIDEND_VALUATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_DIVIDEND_VALUATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_DIVIDEND_VALUATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEX_EVENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEX_EVENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEX_EVENT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEX_EVENT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEX_EVENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEX_EVENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEX_EVENT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEX_EVENT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEX_EVENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEX_EVENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEX_EVENT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEX_EVENT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEX_EVENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEX_EVENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEX_EVENT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEX_EVENT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEX_EVENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEX_EVENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEX_EVENT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEX_EVENT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceTimeType_EXPIRATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceTimeType_EXPIRATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceTimeType_EXPIRATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_EXPIRATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceTimeType_IMMEDIATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceTimeType_IMMEDIATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceTimeType_IMMEDIATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_IMMEDIATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceTimeType_SPECIFIED_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceTimeType_SPECIFIED_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceTimeType_SPECIFIED_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_SPECIFIED_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceTimeType_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceTimeType_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceTimeType_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceTimeType_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceTimeType_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceTimeType_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceTimeType_OFFICIAL_SETTL_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceTimeType_OFFICIAL_SETTL_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceTimeType_OFFICIAL_SETTL_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_OFFICIAL_SETTL_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceTimeType_DERIVATIVES_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceTimeType_DERIVATIVES_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceTimeType_DERIVATIVES_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_DERIVATIVES_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceTimeType_AS_SPECIFIED_MASTER_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceTimeType_AS_SPECIFIED_MASTER_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceTimeType_AS_SPECIFIED_MASTER_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_AS_SPECIFIED_MASTER_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventCondition_AND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventCondition_AND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventCondition_AND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventCondition_AND));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventCondition_OR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventCondition_OR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventCondition_OR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventCondition_OR));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnRejReason_UNKNOWN_CLIENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnRejReason_UNKNOWN_CLIENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnRejReason_UNKNOWN_CLIENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_UNKNOWN_CLIENT));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnRejReason_NO_AVAILABLE_STREAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnRejReason_NO_AVAILABLE_STREAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnRejReason_NO_AVAILABLE_STREAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_NO_AVAILABLE_STREAM));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnRejReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnRejReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnAckType_ASSIGNMENT_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnAckType_ASSIGNMENT_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnAckType_ASSIGNMENT_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnAckType_ASSIGNMENT_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnAckType_ASSIGNMENT_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnAckType_ASSIGNMENT_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnAckType_ASSIGNMENT_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnAckType_ASSIGNMENT_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnType_ASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnType_ASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnType_ASSIGNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_ASSIGNMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnType_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnType_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnType_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnType_TERMINATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnType_TERMINATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnType_TERMINATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_TERMINATE));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchInst_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchInst_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchInst_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchInst_MATCH));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchInst_DO_NOT_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchInst_DO_NOT_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchInst_DO_NOT_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchInst_DO_NOT_MATCH));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerScope_THIS_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerScope_THIS_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerScope_THIS_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TriggerScope_THIS_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerScope_OTHER_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerScope_OTHER_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerScope_OTHER_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TriggerScope_OTHER_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_AND_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_AND_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_AND_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_AND_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_AND_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_AND_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_AND_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_AND_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_PRICE_AND_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_PRICE_AND_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_PRICE_AND_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_PRICE_AND_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_LimitAmtType_CREDIT_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LimitAmtType_CREDIT_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LimitAmtType_CREDIT_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LimitAmtType_CREDIT_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_LimitAmtType_GROSS_POSITION_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LimitAmtType_GROSS_POSITION_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LimitAmtType_GROSS_POSITION_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LimitAmtType_GROSS_POSITION_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_LimitAmtType_NET_POSITION_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LimitAmtType_NET_POSITION_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LimitAmtType_NET_POSITION_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LimitAmtType_NET_POSITION_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_LimitAmtType_RISK_EXPOSURE_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LimitAmtType_RISK_EXPOSURE_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LimitAmtType_RISK_EXPOSURE_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LimitAmtType_RISK_EXPOSURE_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_LimitAmtType_LONG_POSITION_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LimitAmtType_LONG_POSITION_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LimitAmtType_LONG_POSITION_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LimitAmtType_LONG_POSITION_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_LimitAmtType_SHORT_POSITION_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LimitAmtType_SHORT_POSITION_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LimitAmtType_SHORT_POSITION_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LimitAmtType_SHORT_POSITION_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtInqQualifier_SUMMARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtInqQualifier_SUMMARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtInqQualifier_SUMMARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtInqQualifier_SUMMARY));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtInqQualifier_DETAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtInqQualifier_DETAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtInqQualifier_DETAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtInqQualifier_DETAIL));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtInqQualifier_EXCESS_DEFICIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtInqQualifier_EXCESS_DEFICIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtInqQualifier_EXCESS_DEFICIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtInqQualifier_EXCESS_DEFICIT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtInqQualifier_NET_POSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtInqQualifier_NET_POSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtInqQualifier_NET_POSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtInqQualifier_NET_POSITION));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtRptType_SUMMARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtRptType_SUMMARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtRptType_SUMMARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtRptType_SUMMARY));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtRptType_DETAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtRptType_DETAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtRptType_DETAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtRptType_DETAIL));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtRptType_EXCESS_DEFICIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtRptType_EXCESS_DEFICIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtRptType_EXCESS_DEFICIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtRptType_EXCESS_DEFICIT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtInqResult_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtInqResult_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtInqResult_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtInqResult_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtInqResult_INVALID_OR_UNKNOWN_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtInqResult_INVALID_OR_UNKNOWN_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtInqResult_INVALID_OR_UNKNOWN_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtInqResult_INVALID_OR_UNKNOWN_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtInqResult_INVALID_OR_UNKNOWN_MARGIN_CLASS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtInqResult_INVALID_OR_UNKNOWN_MARGIN_CLASS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtInqResult_INVALID_OR_UNKNOWN_MARGIN_CLASS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtInqResult_INVALID_OR_UNKNOWN_MARGIN_CLASS));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtInqResult_INVALID_PARTIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtInqResult_INVALID_PARTIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtInqResult_INVALID_PARTIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtInqResult_INVALID_PARTIES));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtInqResult_INVALID_TRANSPORT_TYPE_REQ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtInqResult_INVALID_TRANSPORT_TYPE_REQ is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtInqResult_INVALID_TRANSPORT_TYPE_REQ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtInqResult_INVALID_TRANSPORT_TYPE_REQ));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtInqResult_INVALID_DESTINATION_REQ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtInqResult_INVALID_DESTINATION_REQ is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtInqResult_INVALID_DESTINATION_REQ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtInqResult_INVALID_DESTINATION_REQ));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtInqResult_NO_MARGIN_REQ_FOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtInqResult_NO_MARGIN_REQ_FOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtInqResult_NO_MARGIN_REQ_FOUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtInqResult_NO_MARGIN_REQ_FOUND));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtInqResult_MARGIN_REQ_INQUIRY_QUALIFIER_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtInqResult_MARGIN_REQ_INQUIRY_QUALIFIER_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtInqResult_MARGIN_REQ_INQUIRY_QUALIFIER_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtInqResult_MARGIN_REQ_INQUIRY_QUALIFIER_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtInqResult_UNAUTHORIZED_FOR_MARGIN_REQ_INQUIRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtInqResult_UNAUTHORIZED_FOR_MARGIN_REQ_INQUIRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtInqResult_UNAUTHORIZED_FOR_MARGIN_REQ_INQUIRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtInqResult_UNAUTHORIZED_FOR_MARGIN_REQ_INQUIRY));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginReqmtInqResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginReqmtInqResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginReqmtInqResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginReqmtInqResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_ADDITIONAL_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_ADDITIONAL_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_ADDITIONAL_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_ADDITIONAL_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_ADJUSTED_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_ADJUSTED_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_ADJUSTED_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_ADJUSTED_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_UNADJUSTED_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_UNADJUSTED_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_UNADJUSTED_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_UNADJUSTED_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_BINARY_ADD_ON_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_BINARY_ADD_ON_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_BINARY_ADD_ON_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_BINARY_ADD_ON_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_CASH_BALANCE_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_CASH_BALANCE_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_CASH_BALANCE_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_CASH_BALANCE_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_CONCENTRATION_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_CONCENTRATION_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_CONCENTRATION_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_CONCENTRATION_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_CORE_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_CORE_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_CORE_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_CORE_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_DELIVERY_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_DELIVERY_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_DELIVERY_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_DELIVERY_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_DISCRETIONARY_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_DISCRETIONARY_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_DISCRETIONARY_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_DISCRETIONARY_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_FUTURES_SPREAD_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_FUTURES_SPREAD_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_FUTURES_SPREAD_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_FUTURES_SPREAD_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_INITIAL_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_INITIAL_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_INITIAL_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_INITIAL_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_LIQUIDATING_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_LIQUIDATING_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_LIQUIDATING_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_LIQUIDATING_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_MARGIN_CALL_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_MARGIN_CALL_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_MARGIN_CALL_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_MARGIN_CALL_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_MARGIN_DEFICIT_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_MARGIN_DEFICIT_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_MARGIN_DEFICIT_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_MARGIN_DEFICIT_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_MARGIN_EXCESS_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_MARGIN_EXCESS_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_MARGIN_EXCESS_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_MARGIN_EXCESS_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_OPTION_PREMIUM_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_OPTION_PREMIUM_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_OPTION_PREMIUM_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_OPTION_PREMIUM_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_PREMIUM_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_PREMIUM_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_PREMIUM_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_PREMIUM_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_RESERVE_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_RESERVE_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_RESERVE_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_RESERVE_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_SECURITY_COLLATERAL_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_SECURITY_COLLATERAL_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_SECURITY_COLLATERAL_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_SECURITY_COLLATERAL_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_STRESS_TEST_ADD_ON_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_STRESS_TEST_ADD_ON_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_STRESS_TEST_ADD_ON_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_STRESS_TEST_ADD_ON_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_SUPER_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_SUPER_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_SUPER_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_SUPER_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_TOTAL_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_TOTAL_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_TOTAL_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_TOTAL_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_VARIATION_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_VARIATION_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_VARIATION_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_VARIATION_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_SECONDARY_VARIATION_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_SECONDARY_VARIATION_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_SECONDARY_VARIATION_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_SECONDARY_VARIATION_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_ROLLED_UP_MARGIN_DEFICIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_ROLLED_UP_MARGIN_DEFICIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_ROLLED_UP_MARGIN_DEFICIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_ROLLED_UP_MARGIN_DEFICIT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_SPREAD_RESPONSE_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_SPREAD_RESPONSE_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_SPREAD_RESPONSE_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_SPREAD_RESPONSE_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_SYSTEMIC_RISK_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_SYSTEMIC_RISK_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_SYSTEMIC_RISK_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_SYSTEMIC_RISK_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_CURVE_RISK_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_CURVE_RISK_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_CURVE_RISK_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_CURVE_RISK_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_INDEX_SPREAD_RISK_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_INDEX_SPREAD_RISK_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_INDEX_SPREAD_RISK_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_INDEX_SPREAD_RISK_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_SECTOR_RISK_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_SECTOR_RISK_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_SECTOR_RISK_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_SECTOR_RISK_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_JUMP_TO_DEFAULT_RISK_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_JUMP_TO_DEFAULT_RISK_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_JUMP_TO_DEFAULT_RISK_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_JUMP_TO_DEFAULT_RISK_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_BASIS_RISK_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_BASIS_RISK_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_BASIS_RISK_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_BASIS_RISK_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_INTEREST_RATE_RISK_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_INTEREST_RATE_RISK_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_INTEREST_RATE_RISK_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_INTEREST_RATE_RISK_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_JUMP_TO_HEALTH_RISK_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_JUMP_TO_HEALTH_RISK_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_JUMP_TO_HEALTH_RISK_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_JUMP_TO_HEALTH_RISK_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginAmtType_OTHER_RISK_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginAmtType_OTHER_RISK_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginAmtType_OTHER_RISK_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginAmtType_OTHER_RISK_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedInstrumentType_HEDGES_FOR_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedInstrumentType_HEDGES_FOR_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedInstrumentType_HEDGES_FOR_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedInstrumentType_HEDGES_FOR_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedInstrumentType_UNDERLIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedInstrumentType_UNDERLIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedInstrumentType_UNDERLIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedInstrumentType_UNDERLIER));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedInstrumentType_EQUITY_EQUIVALENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedInstrumentType_EQUITY_EQUIVALENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedInstrumentType_EQUITY_EQUIVALENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedInstrumentType_EQUITY_EQUIVALENT));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedInstrumentType_NEAREST_EXCHANGE_TRADED_CONTRACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedInstrumentType_NEAREST_EXCHANGE_TRADED_CONTRACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedInstrumentType_NEAREST_EXCHANGE_TRADED_CONTRACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedInstrumentType_NEAREST_EXCHANGE_TRADED_CONTRACT));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedInstrumentType_RETAIL_EQUIVALENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedInstrumentType_RETAIL_EQUIVALENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedInstrumentType_RETAIL_EQUIVALENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedInstrumentType_RETAIL_EQUIVALENT));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedInstrumentType_LEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedInstrumentType_LEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedInstrumentType_LEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedInstrumentType_LEG));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketMakerActivity_NO_PARTICIPATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketMakerActivity_NO_PARTICIPATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketMakerActivity_NO_PARTICIPATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketMakerActivity_NO_PARTICIPATION));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketMakerActivity_BUY_PARTICIPATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketMakerActivity_BUY_PARTICIPATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketMakerActivity_BUY_PARTICIPATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketMakerActivity_BUY_PARTICIPATION));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketMakerActivity_SELL_PARTICIPATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketMakerActivity_SELL_PARTICIPATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketMakerActivity_SELL_PARTICIPATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketMakerActivity_SELL_PARTICIPATION));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketMakerActivity_BOTH_BUY_AND_SELL_PARTICIPATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketMakerActivity_BOTH_BUY_AND_SELL_PARTICIPATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketMakerActivity_BOTH_BUY_AND_SELL_PARTICIPATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketMakerActivity_BOTH_BUY_AND_SELL_PARTICIPATION));
  return pyobj;
}


SWIGINTERN int Swig_var_RequestResult_VALID_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RequestResult_VALID_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RequestResult_VALID_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RequestResult_VALID_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_RequestResult_INVALID_OR_UNSUPPORTED_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RequestResult_INVALID_OR_UNSUPPORTED_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RequestResult_INVALID_OR_UNSUPPORTED_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RequestResult_INVALID_OR_UNSUPPORTED_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_RequestResult_NO_DATA_FOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RequestResult_NO_DATA_FOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RequestResult_NO_DATA_FOUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RequestResult_NO_DATA_FOUND));
  return pyobj;
}


SWIGINTERN int Swig_var_RequestResult_NOT_AUTHORIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RequestResult_NOT_AUTHORIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RequestResult_NOT_AUTHORIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RequestResult_NOT_AUTHORIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_RequestResult_DATA_TEMPORARILY_UNAVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RequestResult_DATA_TEMPORARILY_UNAVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RequestResult_DATA_TEMPORARILY_UNAVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RequestResult_DATA_TEMPORARILY_UNAVAILABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_RequestResult_REQUEST_FOR_DATA_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RequestResult_REQUEST_FOR_DATA_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RequestResult_REQUEST_FOR_DATA_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RequestResult_REQUEST_FOR_DATA_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RequestResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RequestResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RequestResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RequestResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_IS_ALSO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_IS_ALSO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_IS_ALSO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_IS_ALSO));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_CLEARS_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_CLEARS_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_CLEARS_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_CLEARS_FOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_CLEARS_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_CLEARS_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_CLEARS_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_CLEARS_THROUGH));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_TRADES_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_TRADES_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_TRADES_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_TRADES_FOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_TRADES_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_TRADES_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_TRADES_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_TRADES_THROUGH));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_SPONSORS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_SPONSORS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_SPONSORS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_SPONSORS));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_SPONSORED_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_SPONSORED_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_SPONSORED_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_SPONSORED_THROUGH));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_PROVIDES_GUARANTEE_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_PROVIDES_GUARANTEE_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_IS_GUARANTEED_BY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_IS_GUARANTEED_BY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_MEMBER_OF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_MEMBER_OF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_MEMBER_OF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_MEMBER_OF));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_HAS_MEMBERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_HAS_MEMBERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_HAS_MEMBERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_HAS_MEMBERS));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_PROVIDES_MARKETPLACE_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_PROVIDES_MARKETPLACE_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_PARTICIPANT_OF_MARKETPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_PARTICIPANT_OF_MARKETPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_CARRIES_POSITIONS_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_CARRIES_POSITIONS_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_POSTS_TRADES_TO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_POSTS_TRADES_TO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_ENTERS_TRADES_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_ENTERS_TRADES_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_ENTERS_TRADES_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_ENTERS_TRADES_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_PROVIDES_QUOTES_TO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_PROVIDES_QUOTES_TO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_REQUESTS_QUOTES_FROM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_REQUESTS_QUOTES_FROM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_INVESTS_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_INVESTS_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_INVESTS_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_INVESTS_FOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_INVESTS_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_INVESTS_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_INVESTS_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_INVESTS_THROUGH));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_BROKERS_TRADES_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_BROKERS_TRADES_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_BROKERS_TRADES_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_BROKERS_TRADES_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_PROVIDES_TRADING_SERVICES_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_PROVIDES_TRADING_SERVICES_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_USES_TRADING_SERVICES_OF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_USES_TRADING_SERVICES_OF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_APPROVES_OF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_APPROVES_OF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_APPROVES_OF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_APPROVES_OF));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_APPROVED_BY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_APPROVED_BY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_APPROVED_BY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_APPROVED_BY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_PARENT_FIRM_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_PARENT_FIRM_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_SUBSIDIARY_OF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_SUBSIDIARY_OF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_SUBSIDIARY_OF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_SUBSIDIARY_OF));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_REGULATORY_OWNER_OF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_REGULATORY_OWNER_OF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_OWNED_BY_REGULATORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_OWNED_BY_REGULATORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_OWNED_BY_REGULATORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_OWNED_BY_REGULATORY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_CONTROLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_CONTROLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_CONTROLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_CONTROLS));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_IS_CONTROLLED_BY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_IS_CONTROLLED_BY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_LEGAL_OWNER_OF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_LEGAL_OWNER_OF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_LEGAL_OWNER_OF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_LEGAL_OWNER_OF));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_OWNED_BY_LEGAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_OWNED_BY_LEGAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_OWNED_BY_LEGAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_OWNED_BY_LEGAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_BENEFICIAL_OWNER_OF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_BENEFICIAL_OWNER_OF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_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 Swig_var_PartyRelationship_OWNED_BY_BENEFICIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_OWNED_BY_BENEFICIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_OWNED_BY_BENEFICIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_OWNED_BY_BENEFICIAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_SETTLES_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_SETTLES_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_SETTLES_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_SETTLES_FOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRelationship_SETTLES_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_SETTLES_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRelationship_SETTLES_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_SETTLES_THROUGH));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_CREDIT_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_CREDIT_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_CREDIT_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_CREDIT_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_GROSS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_GROSS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_GROSS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_GROSS_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_NET_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_NET_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_NET_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_NET_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_EXPOSURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_EXPOSURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_EXPOSURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_EXPOSURE));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_LONG_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_LONG_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_LONG_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_LONG_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_SHORT_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_SHORT_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_SHORT_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_SHORT_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_CASH_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_CASH_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_CASH_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_CASH_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_ADDITIONAL_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_ADDITIONAL_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_ADDITIONAL_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_ADDITIONAL_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_TOTAL_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_TOTAL_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_TOTAL_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_TOTAL_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_LIMIT_CONSUMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_LIMIT_CONSUMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_LIMIT_CONSUMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_LIMIT_CONSUMED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_CLIP_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_CLIP_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_CLIP_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_CLIP_SIZE));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_MAX_NOTIONAL_ORDER_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_MAX_NOTIONAL_ORDER_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_MAX_NOTIONAL_ORDER_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_MAX_NOTIONAL_ORDER_SIZE));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_DV01_PV01_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_DV01_PV01_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_DV01_PV01_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_DV01_PV01_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_CS01_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_CS01_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_CS01_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_CS01_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_VOLUME_LIMIT_PER_TIME_PERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_VOLUME_LIMIT_PER_TIME_PERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_VOLUME_LIMIT_PER_TIME_PERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_VOLUME_LIMIT_PER_TIME_PERIOD));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_VOL_FILLED_PCT_ORD_VOL_TM_PERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_VOL_FILLED_PCT_ORD_VOL_TM_PERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_VOL_FILLED_PCT_ORD_VOL_TM_PERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_VOL_FILLED_PCT_ORD_VOL_TM_PERIOD));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_NOTL_FILLED_PCT_NOTL_TM_PERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_NOTL_FILLED_PCT_NOTL_TM_PERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_NOTL_FILLED_PCT_NOTL_TM_PERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_NOTL_FILLED_PCT_NOTL_TM_PERIOD));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitType_TRANSACTION_EXECUTION_LIMIT_PER_TIME_PERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_TRANSACTION_EXECUTION_LIMIT_PER_TIME_PERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitType_TRANSACTION_EXECUTION_LIMIT_PER_TIME_PERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_TRANSACTION_EXECUTION_LIMIT_PER_TIME_PERIOD));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrumentScopeOperator_INCLUDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrumentScopeOperator_INCLUDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrumentScopeOperator_INCLUDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrumentScopeOperator_INCLUDE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrumentScopeOperator_EXCLUDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrumentScopeOperator_EXCLUDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrumentScopeOperator_EXCLUDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrumentScopeOperator_EXCLUDE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailStatus_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailStatus_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailStatus_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailStatus_ACTIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailStatus_SUSPENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailStatus_SUSPENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailStatus_SUSPENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailStatus_SUSPENDED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailStatus_HALTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailStatus_HALTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailStatus_HALTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailStatus_HALTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_FIRM_OR_LEGAL_ENTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_FIRM_OR_LEGAL_ENTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_FIRM_OR_LEGAL_ENTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_FIRM_OR_LEGAL_ENTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_CURRENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_CURRENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_CURRENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_CURRENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_NATURAL_PERSON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_NATURAL_PERSON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_NATURAL_PERSON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_NATURAL_PERSON));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_AGENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_RISKLESS_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_RISKLESS_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_RISKLESS_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_RISKLESS_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_EXCHANGE_ORDER_SUBMITTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_EXCHANGE_ORDER_SUBMITTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_EXCHANGE_ORDER_SUBMITTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_EXCHANGE_ORDER_SUBMITTER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_PRIMARY_TRD_REPOSITORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_PRIMARY_TRD_REPOSITORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_PRIMARY_TRD_REPOSITORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_PRIMARY_TRD_REPOSITORY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_ORIG_TRD_REPOSITORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_ORIG_TRD_REPOSITORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_ORIG_TRD_REPOSITORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_ORIG_TRD_REPOSITORY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_ADDTNL_INTL_TRD_REPOSITORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_ADDTNL_INTL_TRD_REPOSITORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_ADDTNL_INTL_TRD_REPOSITORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_ADDTNL_INTL_TRD_REPOSITORY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_ADDTNL_DOMESTIC_TRD_REPOSITORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_ADDTNL_DOMESTIC_TRD_REPOSITORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_ADDTNL_DOMESTIC_TRD_REPOSITORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_ADDTNL_DOMESTIC_TRD_REPOSITORY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_REGULAR_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_REGULAR_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_REGULAR_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_REGULAR_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_HEAD_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_HEAD_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_HEAD_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_HEAD_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_SUPERVISOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_SUPERVISOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_SUPERVISOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_SUPERVISOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_ALGORITHM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_ALGORITHM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_ALGORITHM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_ALGORITHM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_RELATED_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_RELATED_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_RELATED_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_RELATED_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_OPTIONS_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_OPTIONS_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_OPTIONS_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_OPTIONS_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_SPECIFIED_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_SPECIFIED_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_SPECIFIED_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_SPECIFIED_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_CONSTITUENT_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_CONSTITUENT_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_CONSTITUENT_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_CONSTITUENT_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_BANK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_BANK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_BANK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_BANK));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_HUB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_HUB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_HUB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_HUB));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_TRI_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_TRI_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_TRI_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_TRI_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_LENDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_LENDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_LENDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_LENDER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_GENERAL_CLEARING_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_GENERAL_CLEARING_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_GENERAL_CLEARING_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_GENERAL_CLEARING_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_INDIVIDUAL_CLEARING_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_INDIVIDUAL_CLEARING_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_INDIVIDUAL_CLEARING_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_INDIVIDUAL_CLEARING_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_PREFERRED_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_PREFERRED_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_PREFERRED_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_PREFERRED_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_DIRECTED_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_DIRECTED_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_DIRECTED_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_DIRECTED_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_DESIGNATED_SPONSOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_DESIGNATED_SPONSOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_DESIGNATED_SPONSOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_DESIGNATED_SPONSOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_SPECIALIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_SPECIALIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_SPECIALIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_SPECIALIST));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRoleQualifier_EXEMPT_FROM_TRADE_REPORTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRoleQualifier_EXEMPT_FROM_TRADE_REPORTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRoleQualifier_EXEMPT_FROM_TRADE_REPORTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRoleQualifier_EXEMPT_FROM_TRADE_REPORTING));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdAckStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdAckStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdAckStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdAckStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdAckStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdAckStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdAckStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdAckStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdAckStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdAckStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdAckStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdAckStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityClassificationReason_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityClassificationReason_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityClassificationReason_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityClassificationReason_FEE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityClassificationReason_CREDIT_CONTROLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityClassificationReason_CREDIT_CONTROLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityClassificationReason_CREDIT_CONTROLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityClassificationReason_CREDIT_CONTROLS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityClassificationReason_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityClassificationReason_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityClassificationReason_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityClassificationReason_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityClassificationReason_ENTITLEMENT_OR_ELIGIBILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityClassificationReason_ENTITLEMENT_OR_ELIGIBILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityClassificationReason_ENTITLEMENT_OR_ELIGIBILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityClassificationReason_ENTITLEMENT_OR_ELIGIBILITY));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityClassificationReason_MARKET_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityClassificationReason_MARKET_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityClassificationReason_MARKET_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityClassificationReason_MARKET_DATA));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityClassificationReason_ACCOUNT_SELECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityClassificationReason_ACCOUNT_SELECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityClassificationReason_ACCOUNT_SELECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityClassificationReason_ACCOUNT_SELECTION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityClassificationReason_DELIVERY_PROCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityClassificationReason_DELIVERY_PROCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityClassificationReason_DELIVERY_PROCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityClassificationReason_DELIVERY_PROCESS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityClassificationReason_SECTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityClassificationReason_SECTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityClassificationReason_SECTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityClassificationReason_SECTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtReason_OPTIONS_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtReason_OPTIONS_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtReason_OPTIONS_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosAmtReason_OPTIONS_SETTLEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtReason_PENDING_EROSION_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtReason_PENDING_EROSION_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtReason_PENDING_EROSION_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosAmtReason_PENDING_EROSION_ADJUSTMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtReason_FINAL_EROSION_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtReason_FINAL_EROSION_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtReason_FINAL_EROSION_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosAmtReason_FINAL_EROSION_ADJUSTMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtReason_TEAR_UP_COUPON_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtReason_TEAR_UP_COUPON_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtReason_TEAR_UP_COUPON_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosAmtReason_TEAR_UP_COUPON_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtReason_PRICE_ALIGNMENT_INTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtReason_PRICE_ALIGNMENT_INTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtReason_PRICE_ALIGNMENT_INTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosAmtReason_PRICE_ALIGNMENT_INTEREST));
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtReason_DELIVERY_INVOICE_CHARGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtReason_DELIVERY_INVOICE_CHARGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtReason_DELIVERY_INVOICE_CHARGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosAmtReason_DELIVERY_INVOICE_CHARGES));
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtReason_DELIVERY_STORAGE_CHARGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtReason_DELIVERY_STORAGE_CHARGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtReason_DELIVERY_STORAGE_CHARGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosAmtReason_DELIVERY_STORAGE_CHARGES));
  return pyobj;
}


SWIGINTERN int Swig_var_SideClearingTradePriceType_TRADE_CLEARING_AT_EXECUTION_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideClearingTradePriceType_TRADE_CLEARING_AT_EXECUTION_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideClearingTradePriceType_TRADE_CLEARING_AT_EXECUTION_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideClearingTradePriceType_TRADE_CLEARING_AT_EXECUTION_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_SideClearingTradePriceType_TRADE_CLEARING_AT_ALTERNATE_CLEARING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideClearingTradePriceType_TRADE_CLEARING_AT_ALTERNATE_CLEARING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideClearingTradePriceType_TRADE_CLEARING_AT_ALTERNATE_CLEARING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideClearingTradePriceType_TRADE_CLEARING_AT_ALTERNATE_CLEARING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRejectReason_INVALID_INSTRUMENT_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRejectReason_INVALID_INSTRUMENT_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRejectReason_INVALID_INSTRUMENT_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRejectReason_INVALID_INSTRUMENT_REQUESTED));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRejectReason_INSTRUMENT_ALREADY_EXISTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRejectReason_INSTRUMENT_ALREADY_EXISTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRejectReason_INSTRUMENT_ALREADY_EXISTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRejectReason_INSTRUMENT_ALREADY_EXISTS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRejectReason_REQUEST_TYPE_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRejectReason_REQUEST_TYPE_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRejectReason_REQUEST_TYPE_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRejectReason_REQUEST_TYPE_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRejectReason_SYSTEM_UNAVAILABLE_FOR_INSTRUMENT_CREATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRejectReason_SYSTEM_UNAVAILABLE_FOR_INSTRUMENT_CREATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRejectReason_SYSTEM_UNAVAILABLE_FOR_INSTRUMENT_CREATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRejectReason_SYSTEM_UNAVAILABLE_FOR_INSTRUMENT_CREATION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRejectReason_INELIGIBLE_INSTRUMENT_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRejectReason_INELIGIBLE_INSTRUMENT_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRejectReason_INELIGIBLE_INSTRUMENT_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRejectReason_INELIGIBLE_INSTRUMENT_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRejectReason_INSTRUMENT_ID_UNAVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRejectReason_INSTRUMENT_ID_UNAVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRejectReason_INSTRUMENT_ID_UNAVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRejectReason_INSTRUMENT_ID_UNAVAILABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_OPTION_LEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_OPTION_LEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_OPTION_LEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_OPTION_LEG));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_FUTURE_LEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_FUTURE_LEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_FUTURE_LEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_FUTURE_LEG));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_FX_LEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_FX_LEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_FX_LEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_FX_LEG));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRejectReason_INVALID_LEG_PRICE_SPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRejectReason_INVALID_LEG_PRICE_SPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRejectReason_INVALID_LEG_PRICE_SPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRejectReason_INVALID_LEG_PRICE_SPECIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRejectReason_INVALID_INSTRUMENT_STRUCTURE_SPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRejectReason_INVALID_INSTRUMENT_STRUCTURE_SPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRejectReason_INVALID_INSTRUMENT_STRUCTURE_SPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRejectReason_INVALID_INSTRUMENT_STRUCTURE_SPECIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_ThrottleStatus_THROTTLE_LIMIT_NOT_EXCEEDED_NOT_QUEUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ThrottleStatus_THROTTLE_LIMIT_NOT_EXCEEDED_NOT_QUEUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ThrottleStatus_THROTTLE_LIMIT_NOT_EXCEEDED_NOT_QUEUED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ThrottleStatus_THROTTLE_LIMIT_NOT_EXCEEDED_NOT_QUEUED));
  return pyobj;
}


SWIGINTERN int Swig_var_ThrottleStatus_QUEUED_DUE_TO_THROTTLE_LIMIT_EXCEEDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ThrottleStatus_QUEUED_DUE_TO_THROTTLE_LIMIT_EXCEEDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ThrottleStatus_QUEUED_DUE_TO_THROTTLE_LIMIT_EXCEEDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ThrottleStatus_QUEUED_DUE_TO_THROTTLE_LIMIT_EXCEEDED));
  return pyobj;
}


SWIGINTERN int Swig_var_ThrottleAction_QUEUE_INBOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ThrottleAction_QUEUE_INBOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ThrottleAction_QUEUE_INBOUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ThrottleAction_QUEUE_INBOUND));
  return pyobj;
}


SWIGINTERN int Swig_var_ThrottleAction_QUEUE_OUTBOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ThrottleAction_QUEUE_OUTBOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ThrottleAction_QUEUE_OUTBOUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ThrottleAction_QUEUE_OUTBOUND));
  return pyobj;
}


SWIGINTERN int Swig_var_ThrottleAction_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ThrottleAction_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ThrottleAction_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ThrottleAction_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_ThrottleAction_DISCONNECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ThrottleAction_DISCONNECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ThrottleAction_DISCONNECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ThrottleAction_DISCONNECT));
  return pyobj;
}


SWIGINTERN int Swig_var_ThrottleAction_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ThrottleAction_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ThrottleAction_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ThrottleAction_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_ThrottleType_INBOUND_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ThrottleType_INBOUND_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ThrottleType_INBOUND_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ThrottleType_INBOUND_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ThrottleType_OUTSTANDING_REQUESTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ThrottleType_OUTSTANDING_REQUESTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ThrottleType_OUTSTANDING_REQUESTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ThrottleType_OUTSTANDING_REQUESTS));
  return pyobj;
}


SWIGINTERN int Swig_var_ThrottleInst_REJECT_IF_THROTTLE_LIMIT_EXCEEDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ThrottleInst_REJECT_IF_THROTTLE_LIMIT_EXCEEDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ThrottleInst_REJECT_IF_THROTTLE_LIMIT_EXCEEDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ThrottleInst_REJECT_IF_THROTTLE_LIMIT_EXCEEDED));
  return pyobj;
}


SWIGINTERN int Swig_var_ThrottleInst_QUEUE_IF_THROTTLE_LIMIT_EXCEEDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ThrottleInst_QUEUE_IF_THROTTLE_LIMIT_EXCEEDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ThrottleInst_QUEUE_IF_THROTTLE_LIMIT_EXCEEDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ThrottleInst_QUEUE_IF_THROTTLE_LIMIT_EXCEEDED));
  return pyobj;
}


SWIGINTERN int Swig_var_ThrottleCountIndicator_OUTSTANDING_REQUESTS_UNCHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ThrottleCountIndicator_OUTSTANDING_REQUESTS_UNCHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ThrottleCountIndicator_OUTSTANDING_REQUESTS_UNCHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ThrottleCountIndicator_OUTSTANDING_REQUESTS_UNCHANGED));
  return pyobj;
}


SWIGINTERN int Swig_var_ThrottleCountIndicator_OUTSTANDING_REQUESTS_DECREASED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ThrottleCountIndicator_OUTSTANDING_REQUESTS_DECREASED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ThrottleCountIndicator_OUTSTANDING_REQUESTS_DECREASED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ThrottleCountIndicator_OUTSTANDING_REQUESTS_DECREASED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocationRollupInstruction_ROLLUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocationRollupInstruction_ROLLUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocationRollupInstruction_ROLLUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocationRollupInstruction_ROLLUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocationRollupInstruction_DO_NOT_ROLL_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocationRollupInstruction_DO_NOT_ROLL_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocationRollupInstruction_DO_NOT_ROLL_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocationRollupInstruction_DO_NOT_ROLL_UP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReversalStatus_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReversalStatus_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReversalStatus_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReversalStatus_COMPLETED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReversalStatus_REFUSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReversalStatus_REFUSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReversalStatus_REFUSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReversalStatus_REFUSED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReversalStatus_CANCELLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReversalStatus_CANCELLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReversalStatus_CANCELLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReversalStatus_CANCELLED));
  return pyobj;
}


SWIGINTERN int Swig_var_ObligationType_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ObligationType_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ObligationType_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ObligationType_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_ObligationType_CONVERT_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ObligationType_CONVERT_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ObligationType_CONVERT_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ObligationType_CONVERT_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_ObligationType_MORTGAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ObligationType_MORTGAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ObligationType_MORTGAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ObligationType_MORTGAGE);
  return pyobj;
}


SWIGINTERN int Swig_var_ObligationType_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ObligationType_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ObligationType_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ObligationType_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceNegotiationMethod_PERCENT_PAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceNegotiationMethod_PERCENT_PAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceNegotiationMethod_PERCENT_PAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceNegotiationMethod_PERCENT_PAR));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceNegotiationMethod_DEAL_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceNegotiationMethod_DEAL_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceNegotiationMethod_DEAL_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceNegotiationMethod_DEAL_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceNegotiationMethod_UPFRONT_PNTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceNegotiationMethod_UPFRONT_PNTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceNegotiationMethod_UPFRONT_PNTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceNegotiationMethod_UPFRONT_PNTS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceNegotiationMethod_UPFRONT_AMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceNegotiationMethod_UPFRONT_AMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceNegotiationMethod_UPFRONT_AMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceNegotiationMethod_UPFRONT_AMT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceNegotiationMethod_PAR_UPFRONT_AMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceNegotiationMethod_PAR_UPFRONT_AMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceNegotiationMethod_PAR_UPFRONT_AMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceNegotiationMethod_PAR_UPFRONT_AMT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceNegotiationMethod_SPREAD_UPFRONT_AMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceNegotiationMethod_SPREAD_UPFRONT_AMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceNegotiationMethod_SPREAD_UPFRONT_AMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceNegotiationMethod_SPREAD_UPFRONT_AMT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceNegotiationMethod_UPFRONT_PNTS_AMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceNegotiationMethod_UPFRONT_PNTS_AMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceNegotiationMethod_UPFRONT_PNTS_AMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceNegotiationMethod_UPFRONT_PNTS_AMT));
  return pyobj;
}


SWIGINTERN int Swig_var_UpfrontPriceType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UpfrontPriceType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UpfrontPriceType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UpfrontPriceType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_UpfrontPriceType_FIXED_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UpfrontPriceType_FIXED_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UpfrontPriceType_FIXED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UpfrontPriceType_FIXED_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleRestriction_NO_RESTRICTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleRestriction_NO_RESTRICTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleRestriction_NO_RESTRICTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleRestriction_NO_RESTRICTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleRestriction_SECURITY_NOT_SHORTABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleRestriction_SECURITY_NOT_SHORTABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleRestriction_SECURITY_NOT_SHORTABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleRestriction_SECURITY_NOT_SHORTABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleRestriction_SECURITY_NOT_SHORTABLE_AT_OR_BELOW_BEST_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleRestriction_SECURITY_NOT_SHORTABLE_AT_OR_BELOW_BEST_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleRestriction_SECURITY_NOT_SHORTABLE_AT_OR_BELOW_BEST_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleRestriction_SECURITY_NOT_SHORTABLE_AT_OR_BELOW_BEST_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleRestriction_SECURITY_NOT_SHORTABLE_WITHOUT_PRE_BORROW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleRestriction_SECURITY_NOT_SHORTABLE_WITHOUT_PRE_BORROW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleRestriction_SECURITY_NOT_SHORTABLE_WITHOUT_PRE_BORROW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleRestriction_SECURITY_NOT_SHORTABLE_WITHOUT_PRE_BORROW));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleExemptionReason_EXEMPTION_REASON_UNKNOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleExemptionReason_EXEMPTION_REASON_UNKNOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleExemptionReason_EXEMPTION_REASON_UNKNOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleExemptionReason_EXEMPTION_REASON_UNKNOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleExemptionReason_INCOMING_SSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleExemptionReason_INCOMING_SSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleExemptionReason_INCOMING_SSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleExemptionReason_INCOMING_SSE));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleExemptionReason_ABOVE_NATIONAL_BEST_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleExemptionReason_ABOVE_NATIONAL_BEST_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleExemptionReason_ABOVE_NATIONAL_BEST_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleExemptionReason_ABOVE_NATIONAL_BEST_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleExemptionReason_DELAYED_DELIVERY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleExemptionReason_DELAYED_DELIVERY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleExemptionReason_DELAYED_DELIVERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleExemptionReason_DELAYED_DELIVERY));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleExemptionReason_ODD_LOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleExemptionReason_ODD_LOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleExemptionReason_ODD_LOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleExemptionReason_ODD_LOT));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleExemptionReason_DOMESTIC_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleExemptionReason_DOMESTIC_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleExemptionReason_DOMESTIC_ARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleExemptionReason_DOMESTIC_ARBITRAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleExemptionReason_INTERNATIONAL_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleExemptionReason_INTERNATIONAL_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleExemptionReason_INTERNATIONAL_ARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleExemptionReason_INTERNATIONAL_ARBITRAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleExemptionReason_UNDERWRITER_OR_SYNDICATE_DISTRIBUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleExemptionReason_UNDERWRITER_OR_SYNDICATE_DISTRIBUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleExemptionReason_UNDERWRITER_OR_SYNDICATE_DISTRIBUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleExemptionReason_UNDERWRITER_OR_SYNDICATE_DISTRIBUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleExemptionReason_RISKLESS_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleExemptionReason_RISKLESS_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleExemptionReason_RISKLESS_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleExemptionReason_RISKLESS_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleExemptionReason_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleExemptionReason_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleExemptionReason_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleExemptionReason_VWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplLevelRecoveryIndicator_NO_APPL_RECOVERY_NEEDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplLevelRecoveryIndicator_NO_APPL_RECOVERY_NEEDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplLevelRecoveryIndicator_NO_APPL_RECOVERY_NEEDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplLevelRecoveryIndicator_NO_APPL_RECOVERY_NEEDED));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplLevelRecoveryIndicator_APPL_RECOVERY_NEEDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplLevelRecoveryIndicator_APPL_RECOVERY_NEEDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplLevelRecoveryIndicator_APPL_RECOVERY_NEEDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplLevelRecoveryIndicator_APPL_RECOVERY_NEEDED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestType_DEFINITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestType_DEFINITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestType_DEFINITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestType_DEFINITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestType_UTILIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestType_UTILIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestType_UTILIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestType_UTILIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestType_DEFINITIONS_AND_UTILIZATIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestType_DEFINITIONS_AND_UTILIZATIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestType_DEFINITIONS_AND_UTILIZATIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestType_DEFINITIONS_AND_UTILIZATIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_INVALID_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_INVALID_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_INVALID_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_INVALID_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_INVALID_RELATED_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_INVALID_RELATED_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_INVALID_RELATED_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_INVALID_RELATED_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_INVALID_RISK_LIMIT_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_INVALID_RISK_LIMIT_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_INVALID_RISK_LIMIT_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_INVALID_RISK_LIMIT_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_INVALID_RISK_LIMIT_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_INVALID_RISK_LIMIT_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_INVALID_RISK_LIMIT_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_INVALID_RISK_LIMIT_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_INVALID_RISK_LIMIT_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_INVALID_RISK_LIMIT_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_INVALID_RISK_LIMIT_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_INVALID_RISK_LIMIT_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_INVALID_RISK_WARNING_LEVEL_ACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_INVALID_RISK_WARNING_LEVEL_ACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_INVALID_RISK_WARNING_LEVEL_ACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_INVALID_RISK_WARNING_LEVEL_ACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_INVALID_RISK_INSTRUMENT_SCOPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_INVALID_RISK_INSTRUMENT_SCOPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_INVALID_RISK_INSTRUMENT_SCOPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_INVALID_RISK_INSTRUMENT_SCOPE));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_RISK_LIMIT_ACTIONS_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_RISK_LIMIT_ACTIONS_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_RISK_LIMIT_ACTIONS_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_RISK_LIMIT_ACTIONS_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_WARNING_LEVELS_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_WARNING_LEVELS_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_WARNING_LEVELS_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_WARNING_LEVELS_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_WARNING_LEVEL_ACTIONS_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_WARNING_LEVEL_ACTIONS_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_WARNING_LEVEL_ACTIONS_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_WARNING_LEVEL_ACTIONS_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_RISK_INSTRUMENT_SCOPE_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_RISK_INSTRUMENT_SCOPE_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_RISK_INSTRUMENT_SCOPE_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_RISK_INSTRUMENT_SCOPE_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_RISK_LIMIT_NOT_APPROVED_FOR_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_RISK_LIMIT_NOT_APPROVED_FOR_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_RISK_LIMIT_NOT_APPROVED_FOR_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_RISK_LIMIT_NOT_APPROVED_FOR_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_RISK_LIMIT_ALREADY_DEFINED_FOR_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_RISK_LIMIT_ALREADY_DEFINED_FOR_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_RISK_LIMIT_ALREADY_DEFINED_FOR_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_RISK_LIMIT_ALREADY_DEFINED_FOR_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_INSTRUMENT_NOT_APPROVED_FOR_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_INSTRUMENT_NOT_APPROVED_FOR_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_INSTRUMENT_NOT_APPROVED_FOR_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_INSTRUMENT_NOT_APPROVED_FOR_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_NOT_AUTHORIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_NOT_AUTHORIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_NOT_AUTHORIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_NOT_AUTHORIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitRequestResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitRequestResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitRequestResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitRequestResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitAction_QUEUE_INBOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitAction_QUEUE_INBOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitAction_QUEUE_INBOUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitAction_QUEUE_INBOUND));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitAction_QUEUE_OUTBOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitAction_QUEUE_OUTBOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitAction_QUEUE_OUTBOUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitAction_QUEUE_OUTBOUND));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitAction_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitAction_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitAction_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitAction_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitAction_DISCONNECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitAction_DISCONNECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitAction_DISCONNECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitAction_DISCONNECT));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitAction_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitAction_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitAction_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitAction_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitAction_PING_CREDIT_CHECK_WITH_REVALIDATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitAction_PING_CREDIT_CHECK_WITH_REVALIDATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitAction_PING_CREDIT_CHECK_WITH_REVALIDATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitAction_PING_CREDIT_CHECK_WITH_REVALIDATION));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitAction_PING_CREDIT_CHECK_NO_REVALIDATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitAction_PING_CREDIT_CHECK_NO_REVALIDATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitAction_PING_CREDIT_CHECK_NO_REVALIDATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitAction_PING_CREDIT_CHECK_NO_REVALIDATION));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitAction_PUSH_CREDIT_CHECK_WITH_REVALIDATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitAction_PUSH_CREDIT_CHECK_WITH_REVALIDATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitAction_PUSH_CREDIT_CHECK_WITH_REVALIDATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitAction_PUSH_CREDIT_CHECK_WITH_REVALIDATION));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitAction_PUSH_CREDIT_CHECK_NO_REVALIDATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitAction_PUSH_CREDIT_CHECK_NO_REVALIDATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitAction_PUSH_CREDIT_CHECK_NO_REVALIDATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitAction_PUSH_CREDIT_CHECK_NO_REVALIDATION));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitAction_SUSPEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitAction_SUSPEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitAction_SUSPEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitAction_SUSPEND));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitAction_HALT_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitAction_HALT_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitAction_HALT_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitAction_HALT_TRADING));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementType_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementType_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementType_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementType_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementType_MAKE_MARKETS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementType_MAKE_MARKETS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementType_MAKE_MARKETS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementType_MAKE_MARKETS));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementType_HOLD_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementType_HOLD_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementType_HOLD_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementType_HOLD_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementType_PERFORM_GIVE_UPS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementType_PERFORM_GIVE_UPS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementType_PERFORM_GIVE_UPS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementType_PERFORM_GIVE_UPS));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementType_SUBMIT_IO_IS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementType_SUBMIT_IO_IS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementType_SUBMIT_IO_IS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementType_SUBMIT_IO_IS));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementType_SUBSCRIBE_MARKET_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementType_SUBSCRIBE_MARKET_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementType_SUBSCRIBE_MARKET_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementType_SUBSCRIBE_MARKET_DATA));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementType_SHORT_WITH_PRE_BORROW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementType_SHORT_WITH_PRE_BORROW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementType_SHORT_WITH_PRE_BORROW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementType_SHORT_WITH_PRE_BORROW));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementType_SUBMIT_QUOTE_REQUESTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementType_SUBMIT_QUOTE_REQUESTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementType_SUBMIT_QUOTE_REQUESTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementType_SUBMIT_QUOTE_REQUESTS));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementType_RESPOND_TO_QUOTE_REQUESTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementType_RESPOND_TO_QUOTE_REQUESTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementType_RESPOND_TO_QUOTE_REQUESTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementType_RESPOND_TO_QUOTE_REQUESTS));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_TENOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_TENOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_TENOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_TENOR));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_PATTERN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_PATTERN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_PATTERN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_PATTERN));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_RESERVED100_PLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_RESERVED100_PLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_RESERVED100_PLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_RESERVED100_PLUS));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_RESERVED1000_PLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_RESERVED1000_PLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_RESERVED1000_PLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_RESERVED1000_PLUS));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_RESERVED4000_PLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_RESERVED4000_PLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_RESERVED4000_PLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_RESERVED4000_PLUS));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_STRING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_STRING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_STRING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_STRING));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_MULTIPLE_CHAR_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_MULTIPLE_CHAR_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_MULTIPLE_CHAR_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_MULTIPLE_CHAR_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_CURRENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_MONTH_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_MONTH_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_MONTH_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_MONTH_YEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_UTC_TIMESTAMP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_UTC_TIMESTAMP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_UTC_TIMESTAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_UTC_TIMESTAMP));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_UTC_TIME_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_UTC_TIME_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_UTC_TIME_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_UTC_TIME_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_LOCAL_MKT_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_LOCAL_MKT_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_LOCAL_MKT_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_LOCAL_MKT_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_UTC_DATE_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_UTC_DATE_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_UTC_DATE_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_UTC_DATE_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_DATA));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_MULTIPLE_STRING_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_MULTIPLE_STRING_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_MULTIPLE_STRING_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_MULTIPLE_STRING_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_COUNTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_COUNTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_COUNTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_COUNTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_LANGUAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_LANGUAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_LANGUAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_LANGUAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_TZ_TIME_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_TZ_TIME_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_TZ_TIME_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_TZ_TIME_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_TZ_TIMESTAMP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_TZ_TIMESTAMP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_TZ_TIMESTAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_TZ_TIMESTAMP));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_XML_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_XML_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_XML_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_XML_DATA));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_CHAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_CHAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_CHAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_CHAR));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_BOOLEAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_BOOLEAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_BOOLEAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_BOOLEAN));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_FLOAT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_FLOAT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_FLOAT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_FLOAT));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_QTY));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_PRICE_OFFSET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_PRICE_OFFSET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_PRICE_OFFSET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_PRICE_OFFSET));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_AMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_AMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_AMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_AMT));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_INT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_INT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_INT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_INT));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_LENGTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_LENGTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_LENGTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_LENGTH));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_NUM_IN_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_NUM_IN_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_NUM_IN_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_NUM_IN_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_SEQ_NUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_SEQ_NUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_SEQ_NUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_SEQ_NUM));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_TAG_NUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_TAG_NUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_TAG_NUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_TAG_NUM));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementAttribDatatype_DAY_OF_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementAttribDatatype_DAY_OF_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementAttribDatatype_DAY_OF_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementAttribDatatype_DAY_OF_MONTH));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesControl_AUTOMATIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesControl_AUTOMATIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesControl_AUTOMATIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesControl_AUTOMATIC));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesControl_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesControl_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesControl_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesControl_MANUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeVolType_NUMBER_OF_UNITS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeVolType_NUMBER_OF_UNITS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeVolType_NUMBER_OF_UNITS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeVolType_NUMBER_OF_UNITS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeVolType_NUMBER_OF_ROUND_LOTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeVolType_NUMBER_OF_ROUND_LOTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeVolType_NUMBER_OF_ROUND_LOTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeVolType_NUMBER_OF_ROUND_LOTS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventType_ADDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventType_ADDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventType_ADDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventType_ADDED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventType_MODIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventType_MODIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventType_MODIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventType_MODIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventType_DELETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventType_DELETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventType_DELETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventType_DELETED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventType_PARTIALLY_FILLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventType_PARTIALLY_FILLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventType_PARTIALLY_FILLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventType_PARTIALLY_FILLED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventType_FILLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventType_FILLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventType_FILLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventType_FILLED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventType_SUSPENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventType_SUSPENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventType_SUSPENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventType_SUSPENDED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventType_RELEASED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventType_RELEASED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventType_RELEASED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventType_RELEASED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventType_RESTATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventType_RESTATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventType_RESTATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventType_RESTATED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventType_LOCKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventType_LOCKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventType_LOCKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventType_LOCKED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventType_TRIGGERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventType_TRIGGERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventType_TRIGGERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventType_TRIGGERED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventType_ACTIVATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventType_ACTIVATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventType_ACTIVATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventType_ACTIVATED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventReason_ADD_ORDER_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventReason_ADD_ORDER_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventReason_ADD_ORDER_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventReason_ADD_ORDER_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventReason_MODIFY_ORDER_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventReason_MODIFY_ORDER_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventReason_MODIFY_ORDER_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventReason_MODIFY_ORDER_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventReason_DELETE_ORDER_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventReason_DELETE_ORDER_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventReason_DELETE_ORDER_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventReason_DELETE_ORDER_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventReason_ORDER_ENTERED_OOB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventReason_ORDER_ENTERED_OOB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventReason_ORDER_ENTERED_OOB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventReason_ORDER_ENTERED_OOB));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventReason_ORDER_MODIFIED_OOB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventReason_ORDER_MODIFIED_OOB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventReason_ORDER_MODIFIED_OOB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventReason_ORDER_MODIFIED_OOB));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventReason_ORDER_DELETED_OOB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventReason_ORDER_DELETED_OOB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventReason_ORDER_DELETED_OOB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventReason_ORDER_DELETED_OOB));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventReason_ORDER_ACTIVATED_OR_TRIGGERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventReason_ORDER_ACTIVATED_OR_TRIGGERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventReason_ORDER_ACTIVATED_OR_TRIGGERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventReason_ORDER_ACTIVATED_OR_TRIGGERED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventReason_ORDER_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventReason_ORDER_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventReason_ORDER_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventReason_ORDER_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventReason_RESERVE_ORDER_REFRESHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventReason_RESERVE_ORDER_REFRESHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventReason_RESERVE_ORDER_REFRESHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventReason_RESERVE_ORDER_REFRESHED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventReason_AWAY_MARKET_BETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventReason_AWAY_MARKET_BETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventReason_AWAY_MARKET_BETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventReason_AWAY_MARKET_BETTER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventReason_CORPORATE_ACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventReason_CORPORATE_ACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventReason_CORPORATE_ACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventReason_CORPORATE_ACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventReason_START_OF_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventReason_START_OF_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventReason_START_OF_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventReason_START_OF_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEventReason_END_OF_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEventReason_END_OF_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEventReason_END_OF_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderEventReason_END_OF_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_AuctionType_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AuctionType_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AuctionType_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AuctionType_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_AuctionType_BLOCK_ORDER_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AuctionType_BLOCK_ORDER_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AuctionType_BLOCK_ORDER_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AuctionType_BLOCK_ORDER_AUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_AuctionType_DIRECTED_ORDER_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AuctionType_DIRECTED_ORDER_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AuctionType_DIRECTED_ORDER_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AuctionType_DIRECTED_ORDER_AUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_AuctionType_EXPOSURE_ORDER_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AuctionType_EXPOSURE_ORDER_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AuctionType_EXPOSURE_ORDER_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AuctionType_EXPOSURE_ORDER_AUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_AuctionType_FLASH_ORDER_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AuctionType_FLASH_ORDER_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AuctionType_FLASH_ORDER_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AuctionType_FLASH_ORDER_AUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_AuctionType_FACILITATION_ORDER_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AuctionType_FACILITATION_ORDER_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AuctionType_FACILITATION_ORDER_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AuctionType_FACILITATION_ORDER_AUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_AuctionType_SOLICITATION_ORDER_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AuctionType_SOLICITATION_ORDER_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AuctionType_SOLICITATION_ORDER_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AuctionType_SOLICITATION_ORDER_AUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_AuctionType_PRICE_IMPROVEMENT_MECHANISM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AuctionType_PRICE_IMPROVEMENT_MECHANISM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AuctionType_PRICE_IMPROVEMENT_MECHANISM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AuctionType_PRICE_IMPROVEMENT_MECHANISM));
  return pyobj;
}


SWIGINTERN int Swig_var_AuctionType_DIRECTED_ORDER_PRICE_IMPROVEMENT_MECHANISM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AuctionType_DIRECTED_ORDER_PRICE_IMPROVEMENT_MECHANISM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AuctionType_DIRECTED_ORDER_PRICE_IMPROVEMENT_MECHANISM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AuctionType_DIRECTED_ORDER_PRICE_IMPROVEMENT_MECHANISM));
  return pyobj;
}


SWIGINTERN int Swig_var_AuctionInstruction_AUTOMATED_AUCTION_PERMITTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AuctionInstruction_AUTOMATED_AUCTION_PERMITTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AuctionInstruction_AUTOMATED_AUCTION_PERMITTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AuctionInstruction_AUTOMATED_AUCTION_PERMITTED));
  return pyobj;
}


SWIGINTERN int Swig_var_AuctionInstruction_AUTOMATED_AUCTION_NOT_PERMITTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AuctionInstruction_AUTOMATED_AUCTION_NOT_PERMITTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AuctionInstruction_AUTOMATED_AUCTION_NOT_PERMITTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AuctionInstruction_AUTOMATED_AUCTION_NOT_PERMITTED));
  return pyobj;
}


SWIGINTERN int Swig_var_LockType_NOT_LOCKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LockType_NOT_LOCKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LockType_NOT_LOCKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LockType_NOT_LOCKED));
  return pyobj;
}


SWIGINTERN int Swig_var_LockType_AWAY_MARKET_NETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LockType_AWAY_MARKET_NETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LockType_AWAY_MARKET_NETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LockType_AWAY_MARKET_NETTER));
  return pyobj;
}


SWIGINTERN int Swig_var_LockType_THREE_TICK_LOCKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LockType_THREE_TICK_LOCKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LockType_THREE_TICK_LOCKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LockType_THREE_TICK_LOCKED));
  return pyobj;
}


SWIGINTERN int Swig_var_LockType_LOCKED_BY_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LockType_LOCKED_BY_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LockType_LOCKED_BY_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LockType_LOCKED_BY_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_LockType_DIRECTED_ORDER_LOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LockType_DIRECTED_ORDER_LOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LockType_DIRECTED_ORDER_LOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LockType_DIRECTED_ORDER_LOCK));
  return pyobj;
}


SWIGINTERN int Swig_var_LockType_MULTILEG_LOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LockType_MULTILEG_LOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LockType_MULTILEG_LOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LockType_MULTILEG_LOCK));
  return pyobj;
}


SWIGINTERN int Swig_var_LockType_MARKET_ORDER_LOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LockType_MARKET_ORDER_LOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LockType_MARKET_ORDER_LOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LockType_MARKET_ORDER_LOCK));
  return pyobj;
}


SWIGINTERN int Swig_var_LockType_PRE_ASSIGNMENT_LOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LockType_PRE_ASSIGNMENT_LOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LockType_PRE_ASSIGNMENT_LOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LockType_PRE_ASSIGNMENT_LOCK));
  return pyobj;
}


SWIGINTERN int Swig_var_ReleaseInstruction_ISO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReleaseInstruction_ISO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReleaseInstruction_ISO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReleaseInstruction_ISO));
  return pyobj;
}


SWIGINTERN int Swig_var_ReleaseInstruction_NO_AWAY_MARKET_BETTER_CHECK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReleaseInstruction_NO_AWAY_MARKET_BETTER_CHECK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReleaseInstruction_NO_AWAY_MARKET_BETTER_CHECK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReleaseInstruction_NO_AWAY_MARKET_BETTER_CHECK));
  return pyobj;
}


SWIGINTERN int Swig_var_DisclosureType_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisclosureType_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisclosureType_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DisclosureType_VOLUME));
  return pyobj;
}


SWIGINTERN int Swig_var_DisclosureType_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisclosureType_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisclosureType_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DisclosureType_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_DisclosureType_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisclosureType_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisclosureType_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DisclosureType_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_DisclosureType_AON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisclosureType_AON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisclosureType_AON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DisclosureType_AON));
  return pyobj;
}


SWIGINTERN int Swig_var_DisclosureType_GENERAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisclosureType_GENERAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisclosureType_GENERAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DisclosureType_GENERAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DisclosureType_CLEARING_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisclosureType_CLEARING_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisclosureType_CLEARING_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DisclosureType_CLEARING_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_DisclosureType_CMTA_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisclosureType_CMTA_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisclosureType_CMTA_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DisclosureType_CMTA_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_DisclosureInstruction_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisclosureInstruction_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisclosureInstruction_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DisclosureInstruction_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_DisclosureInstruction_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisclosureInstruction_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisclosureInstruction_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DisclosureInstruction_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_DisclosureInstruction_USE_DEFAULT_SETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisclosureInstruction_USE_DEFAULT_SETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisclosureInstruction_USE_DEFAULT_SETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DisclosureInstruction_USE_DEFAULT_SETTING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradingCapacity_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingCapacity_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingCapacity_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradingCapacity_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradingCapacity_CUSTOMER_PROFESSIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingCapacity_CUSTOMER_PROFESSIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingCapacity_CUSTOMER_PROFESSIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradingCapacity_CUSTOMER_PROFESSIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradingCapacity_BROKER_DEALER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingCapacity_BROKER_DEALER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingCapacity_BROKER_DEALER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradingCapacity_BROKER_DEALER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradingCapacity_CUSTOMER_BROKER_DEALER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingCapacity_CUSTOMER_BROKER_DEALER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingCapacity_CUSTOMER_BROKER_DEALER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradingCapacity_CUSTOMER_BROKER_DEALER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradingCapacity_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingCapacity_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingCapacity_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradingCapacity_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradingCapacity_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingCapacity_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingCapacity_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradingCapacity_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradingCapacity_AWAY_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingCapacity_AWAY_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingCapacity_AWAY_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradingCapacity_AWAY_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradingCapacity_SYSTEMATIC_INTERNALISER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingCapacity_SYSTEMATIC_INTERNALISER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingCapacity_SYSTEMATIC_INTERNALISER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradingCapacity_SYSTEMATIC_INTERNALISER));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingAccountType_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingAccountType_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingAccountType_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingAccountType_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingAccountType_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingAccountType_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingAccountType_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingAccountType_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingAccountType_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingAccountType_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingAccountType_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingAccountType_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedPriceSource_NB_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedPriceSource_NB_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedPriceSource_NB_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedPriceSource_NB_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedPriceSource_NB_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedPriceSource_NB_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedPriceSource_NB_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedPriceSource_NB_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_MinQtyMethod_ONCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MinQtyMethod_ONCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MinQtyMethod_ONCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MinQtyMethod_ONCE));
  return pyobj;
}


SWIGINTERN int Swig_var_MinQtyMethod_MULTIPLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MinQtyMethod_MULTIPLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MinQtyMethod_MULTIPLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MinQtyMethod_MULTIPLE));
  return pyobj;
}


SWIGINTERN int Swig_var_Triggered_NOT_TRIGGERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Triggered_NOT_TRIGGERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Triggered_NOT_TRIGGERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Triggered_NOT_TRIGGERED));
  return pyobj;
}


SWIGINTERN int Swig_var_Triggered_TRIGGERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Triggered_TRIGGERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Triggered_TRIGGERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Triggered_TRIGGERED));
  return pyobj;
}


SWIGINTERN int Swig_var_Triggered_STOP_ORDER_TRIGGERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Triggered_STOP_ORDER_TRIGGERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Triggered_STOP_ORDER_TRIGGERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Triggered_STOP_ORDER_TRIGGERED));
  return pyobj;
}


SWIGINTERN int Swig_var_Triggered_OCO_ORDER_TRIGGERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Triggered_OCO_ORDER_TRIGGERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Triggered_OCO_ORDER_TRIGGERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Triggered_OCO_ORDER_TRIGGERED));
  return pyobj;
}


SWIGINTERN int Swig_var_Triggered_OTO_ORDER_TRIGGERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Triggered_OTO_ORDER_TRIGGERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Triggered_OTO_ORDER_TRIGGERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Triggered_OTO_ORDER_TRIGGERED));
  return pyobj;
}


SWIGINTERN int Swig_var_Triggered_OUO_ORDER_TRIGGERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Triggered_OUO_ORDER_TRIGGERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Triggered_OUO_ORDER_TRIGGERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Triggered_OUO_ORDER_TRIGGERED));
  return pyobj;
}


SWIGINTERN int Swig_var_EventTimeUnit_HOUR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventTimeUnit_HOUR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventTimeUnit_HOUR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::EventTimeUnit_HOUR);
  return pyobj;
}


SWIGINTERN int Swig_var_EventTimeUnit_MINUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventTimeUnit_MINUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventTimeUnit_MINUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::EventTimeUnit_MINUTE);
  return pyobj;
}


SWIGINTERN int Swig_var_EventTimeUnit_SECOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventTimeUnit_SECOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventTimeUnit_SECOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::EventTimeUnit_SECOND);
  return pyobj;
}


SWIGINTERN int Swig_var_EventTimeUnit_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventTimeUnit_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventTimeUnit_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::EventTimeUnit_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_EventTimeUnit_WEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventTimeUnit_WEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventTimeUnit_WEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::EventTimeUnit_WEEK);
  return pyobj;
}


SWIGINTERN int Swig_var_EventTimeUnit_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventTimeUnit_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventTimeUnit_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::EventTimeUnit_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_EventTimeUnit_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventTimeUnit_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventTimeUnit_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::EventTimeUnit_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderOrigination_ORDER_RECEIVED_FROM_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderOrigination_ORDER_RECEIVED_FROM_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_WITHIN_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderOrigination_ORDER_RECEIVED_FROM_WITHIN_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_WITHIN_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderOrigination_ORDER_RECEIVED_FROM_WITHIN_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_ANOTHER_BROKER_DEALER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderOrigination_ORDER_RECEIVED_FROM_ANOTHER_BROKER_DEALER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_ANOTHER_BROKER_DEALER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderOrigination_ORDER_RECEIVED_FROM_ANOTHER_BROKER_DEALER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_CUSTOMER_OR_WITH_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderOrigination_ORDER_RECEIVED_FROM_CUSTOMER_OR_WITH_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_CUSTOMER_OR_WITH_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderOrigination_ORDER_RECEIVED_FROM_CUSTOMER_OR_WITH_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_DIRECT_ACCESS_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderOrigination_ORDER_RECEIVED_FROM_DIRECT_ACCESS_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_DIRECT_ACCESS_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderOrigination_ORDER_RECEIVED_FROM_DIRECT_ACCESS_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_FOREIGN_DEALER_EQUIVALENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderOrigination_ORDER_RECEIVED_FROM_FOREIGN_DEALER_EQUIVALENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_FOREIGN_DEALER_EQUIVALENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderOrigination_ORDER_RECEIVED_FROM_FOREIGN_DEALER_EQUIVALENT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_EXECUTION_ONLY_SERVICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderOrigination_ORDER_RECEIVED_FROM_EXECUTION_ONLY_SERVICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_EXECUTION_ONLY_SERVICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderOrigination_ORDER_RECEIVED_FROM_EXECUTION_ONLY_SERVICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearedIndicator_NOT_CLEARED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearedIndicator_NOT_CLEARED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearedIndicator_NOT_CLEARED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearedIndicator_NOT_CLEARED));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearedIndicator_CLEARED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearedIndicator_CLEARED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearedIndicator_CLEARED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearedIndicator_CLEARED));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearedIndicator_SUBMITTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearedIndicator_SUBMITTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearedIndicator_SUBMITTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearedIndicator_SUBMITTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearedIndicator_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearedIndicator_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearedIndicator_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearedIndicator_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ContractRefPosType_TWO_COMPONENT_INTERCOMMODITY_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContractRefPosType_TWO_COMPONENT_INTERCOMMODITY_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContractRefPosType_TWO_COMPONENT_INTERCOMMODITY_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContractRefPosType_TWO_COMPONENT_INTERCOMMODITY_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_ContractRefPosType_INDEX_OR_BASKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContractRefPosType_INDEX_OR_BASKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContractRefPosType_INDEX_OR_BASKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContractRefPosType_INDEX_OR_BASKET));
  return pyobj;
}


SWIGINTERN int Swig_var_ContractRefPosType_TWO_COMPONENT_LOCATION_BASIS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContractRefPosType_TWO_COMPONENT_LOCATION_BASIS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContractRefPosType_TWO_COMPONENT_LOCATION_BASIS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContractRefPosType_TWO_COMPONENT_LOCATION_BASIS));
  return pyobj;
}


SWIGINTERN int Swig_var_ContractRefPosType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContractRefPosType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContractRefPosType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContractRefPosType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionCapacity_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionCapacity_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionCapacity_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PositionCapacity_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionCapacity_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionCapacity_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionCapacity_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PositionCapacity_AGENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionCapacity_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionCapacity_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionCapacity_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PositionCapacity_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionCapacity_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionCapacity_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionCapacity_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PositionCapacity_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_SPECIAL_CUM_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_SPECIAL_CUM_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_SPECIAL_CUM_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_SPECIAL_CUM_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_SPECIAL_CUM_RIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_SPECIAL_CUM_RIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_SPECIAL_CUM_RIGHTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_SPECIAL_CUM_RIGHTS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_SPECIAL_EX_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_SPECIAL_EX_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_SPECIAL_EX_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_SPECIAL_EX_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_SPECIAL_EX_RIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_SPECIAL_EX_RIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_SPECIAL_EX_RIGHTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_SPECIAL_EX_RIGHTS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_SPECIAL_CUM_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_SPECIAL_CUM_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_SPECIAL_CUM_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_SPECIAL_CUM_COUPON));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_SPECIAL_CUM_CAPITAL_REPAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_SPECIAL_CUM_CAPITAL_REPAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_SPECIAL_CUM_CAPITAL_REPAYMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_SPECIAL_CUM_CAPITAL_REPAYMENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_SPECIAL_EX_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_SPECIAL_EX_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_SPECIAL_EX_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_SPECIAL_EX_COUPON));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_SPECIAL_EX_CAPITAL_REPAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_SPECIAL_EX_CAPITAL_REPAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_SPECIAL_EX_CAPITAL_REPAYMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_SPECIAL_EX_CAPITAL_REPAYMENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_CASH_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_CASH_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_CASH_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_CASH_SETTLEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_SPECIAL_CUM_BONUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_SPECIAL_CUM_BONUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_SPECIAL_CUM_BONUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_SPECIAL_CUM_BONUS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_SPECIAL_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_SPECIAL_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_SPECIAL_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_SPECIAL_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_SPECIAL_EX_BONUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_SPECIAL_EX_BONUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_SPECIAL_EX_BONUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_SPECIAL_EX_BONUS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_GUARANTEED_DELIVERY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_GUARANTEED_DELIVERY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_GUARANTEED_DELIVERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_GUARANTEED_DELIVERY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_SPECIAL_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_SPECIAL_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_SPECIAL_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_SPECIAL_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_PRICE_IMPROVEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_PRICE_IMPROVEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_PRICE_IMPROVEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_PRICE_IMPROVEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_NON_PRICE_FORMING_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_NON_PRICE_FORMING_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_NON_PRICE_FORMING_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_NON_PRICE_FORMING_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_TRADE_EXEMPTED_FROM_TRADING_OBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_TRADE_EXEMPTED_FROM_TRADING_OBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_TRADE_EXEMPTED_FROM_TRADING_OBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_TRADE_EXEMPTED_FROM_TRADING_OBLIGATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_PRICE_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_PRICE_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_PRICE_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_PRICE_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePriceCondition_PRICE_NOT_APPLICABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePriceCondition_PRICE_NOT_APPLICABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePriceCondition_PRICE_NOT_APPLICABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePriceCondition_PRICE_NOT_APPLICABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocStatus_PENDING_CLEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocStatus_PENDING_CLEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocStatus_PENDING_CLEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocStatus_PENDING_CLEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocStatus_CLAIMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocStatus_CLAIMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocStatus_CLAIMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocStatus_CLAIMED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocStatus_CLEARED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocStatus_CLEARED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocStatus_CLEARED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocStatus_CLEARED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeQtyType_CLEARED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeQtyType_CLEARED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeQtyType_CLEARED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeQtyType_CLEARED_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeQtyType_LONG_SIDE_CLAIMED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeQtyType_LONG_SIDE_CLAIMED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeQtyType_LONG_SIDE_CLAIMED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeQtyType_LONG_SIDE_CLAIMED_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeQtyType_SHORT_SIDE_CLAIMED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeQtyType_SHORT_SIDE_CLAIMED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeQtyType_SHORT_SIDE_CLAIMED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeQtyType_SHORT_SIDE_CLAIMED_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeQtyType_LONG_SIDE_REJECTED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeQtyType_LONG_SIDE_REJECTED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeQtyType_LONG_SIDE_REJECTED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeQtyType_LONG_SIDE_REJECTED_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeQtyType_SHORT_SIDE_REJECTED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeQtyType_SHORT_SIDE_REJECTED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeQtyType_SHORT_SIDE_REJECTED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeQtyType_SHORT_SIDE_REJECTED_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeQtyType_PENDING_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeQtyType_PENDING_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeQtyType_PENDING_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeQtyType_PENDING_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeQtyType_TRANSACTION_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeQtyType_TRANSACTION_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeQtyType_TRANSACTION_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeQtyType_TRANSACTION_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeQtyType_REMAINING_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeQtyType_REMAINING_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeQtyType_REMAINING_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeQtyType_REMAINING_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeQtyType_PREVIOUS_REMAINING_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeQtyType_PREVIOUS_REMAINING_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeQtyType_PREVIOUS_REMAINING_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeQtyType_PREVIOUS_REMAINING_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocGroupInstruction_ADD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocGroupInstruction_ADD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocGroupInstruction_ADD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocGroupInstruction_ADD));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocGroupInstruction_DO_NOT_ADD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocGroupInstruction_DO_NOT_ADD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocGroupInstruction_DO_NOT_ADD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocGroupInstruction_DO_NOT_ADD));
  return pyobj;
}


SWIGINTERN int Swig_var_OffsetInstruction_OFFSET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OffsetInstruction_OFFSET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OffsetInstruction_OFFSET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OffsetInstruction_OFFSET));
  return pyobj;
}


SWIGINTERN int Swig_var_OffsetInstruction_ONSET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OffsetInstruction_ONSET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OffsetInstruction_ONSET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OffsetInstruction_ONSET));
  return pyobj;
}


SWIGINTERN int Swig_var_SideAvgPxIndicator_NO_AVG_PRICING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideAvgPxIndicator_NO_AVG_PRICING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideAvgPxIndicator_NO_AVG_PRICING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideAvgPxIndicator_NO_AVG_PRICING));
  return pyobj;
}


SWIGINTERN int Swig_var_SideAvgPxIndicator_TRADE_IS_PART_AVG_PRICE_GRP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideAvgPxIndicator_TRADE_IS_PART_AVG_PRICE_GRP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideAvgPxIndicator_TRADE_IS_PART_AVG_PRICE_GRP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideAvgPxIndicator_TRADE_IS_PART_AVG_PRICE_GRP));
  return pyobj;
}


SWIGINTERN int Swig_var_SideAvgPxIndicator_LAST_TRADE_IS_PART_AVG_PRICE_GRP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideAvgPxIndicator_LAST_TRADE_IS_PART_AVG_PRICE_GRP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideAvgPxIndicator_LAST_TRADE_IS_PART_AVG_PRICE_GRP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideAvgPxIndicator_LAST_TRADE_IS_PART_AVG_PRICE_GRP));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedTradeIDSource_NON_FIX_SOURCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedTradeIDSource_NON_FIX_SOURCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedTradeIDSource_NON_FIX_SOURCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedTradeIDSource_NON_FIX_SOURCE));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedTradeIDSource_TRADE_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedTradeIDSource_TRADE_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedTradeIDSource_TRADE_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedTradeIDSource_TRADE_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedTradeIDSource_SECONDARY_TRADE_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedTradeIDSource_SECONDARY_TRADE_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedTradeIDSource_SECONDARY_TRADE_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedTradeIDSource_SECONDARY_TRADE_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedTradeIDSource_TRADE_REPORT_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedTradeIDSource_TRADE_REPORT_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedTradeIDSource_TRADE_REPORT_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedTradeIDSource_TRADE_REPORT_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedTradeIDSource_FIRM_TRADE_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedTradeIDSource_FIRM_TRADE_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedTradeIDSource_FIRM_TRADE_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedTradeIDSource_FIRM_TRADE_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedTradeIDSource_SECONDARY_FIRM_TRADE_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedTradeIDSource_SECONDARY_FIRM_TRADE_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedTradeIDSource_SECONDARY_FIRM_TRADE_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedTradeIDSource_SECONDARY_FIRM_TRADE_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedTradeIDSource_REGULATORY_TRADE_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedTradeIDSource_REGULATORY_TRADE_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedTradeIDSource_REGULATORY_TRADE_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedTradeIDSource_REGULATORY_TRADE_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedPositionIDSource_POS_MAINT_RPT_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedPositionIDSource_POS_MAINT_RPT_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedPositionIDSource_POS_MAINT_RPT_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedPositionIDSource_POS_MAINT_RPT_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedPositionIDSource_TRANSFER_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedPositionIDSource_TRANSFER_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedPositionIDSource_TRANSFER_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedPositionIDSource_TRANSFER_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedPositionIDSource_POSITION_ENTITY_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedPositionIDSource_POSITION_ENTITY_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedPositionIDSource_POSITION_ENTITY_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedPositionIDSource_POSITION_ENTITY_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_ValueCheckType_PRICE_CHECK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValueCheckType_PRICE_CHECK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValueCheckType_PRICE_CHECK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ValueCheckType_PRICE_CHECK));
  return pyobj;
}


SWIGINTERN int Swig_var_ValueCheckType_NOTIONAL_VALUE_CHECK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValueCheckType_NOTIONAL_VALUE_CHECK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValueCheckType_NOTIONAL_VALUE_CHECK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ValueCheckType_NOTIONAL_VALUE_CHECK));
  return pyobj;
}


SWIGINTERN int Swig_var_ValueCheckType_QUANTITY_CHECK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValueCheckType_QUANTITY_CHECK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValueCheckType_QUANTITY_CHECK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ValueCheckType_QUANTITY_CHECK));
  return pyobj;
}


SWIGINTERN int Swig_var_ValueCheckAction_DO_NOT_CHECK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValueCheckAction_DO_NOT_CHECK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValueCheckAction_DO_NOT_CHECK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ValueCheckAction_DO_NOT_CHECK));
  return pyobj;
}


SWIGINTERN int Swig_var_ValueCheckAction_CHECK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValueCheckAction_CHECK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValueCheckAction_CHECK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ValueCheckAction_CHECK));
  return pyobj;
}


SWIGINTERN int Swig_var_ValueCheckAction_BEST_EFFORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValueCheckAction_BEST_EFFORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValueCheckAction_BEST_EFFORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ValueCheckAction_BEST_EFFORT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRequestResult_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRequestResult_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRequestResult_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRequestResult_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRequestResult_INVALID_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRequestResult_INVALID_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRequestResult_INVALID_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRequestResult_INVALID_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRequestResult_INVALID_RELATED_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRequestResult_INVALID_RELATED_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRequestResult_INVALID_RELATED_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRequestResult_INVALID_RELATED_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRequestResult_INVALID_PARTY_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRequestResult_INVALID_PARTY_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRequestResult_INVALID_PARTY_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRequestResult_INVALID_PARTY_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRequestResult_NOT_AUTHORIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRequestResult_NOT_AUTHORIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRequestResult_NOT_AUTHORIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRequestResult_NOT_AUTHORIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRequestResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRequestResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRequestResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRequestResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRequestStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRequestStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRequestStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRequestStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRequestStatus_ACCEPTED_WITH_CHANGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRequestStatus_ACCEPTED_WITH_CHANGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRequestStatus_ACCEPTED_WITH_CHANGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRequestStatus_ACCEPTED_WITH_CHANGES));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRequestStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRequestStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRequestStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRequestStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailRequestStatus_ACCEPTANCE_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailRequestStatus_ACCEPTANCE_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailRequestStatus_ACCEPTANCE_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailRequestStatus_ACCEPTANCE_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailDefinitionStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailDefinitionStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailDefinitionStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailDefinitionStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailDefinitionStatus_ACCEPTED_WITH_CHANGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailDefinitionStatus_ACCEPTED_WITH_CHANGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailDefinitionStatus_ACCEPTED_WITH_CHANGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailDefinitionStatus_ACCEPTED_WITH_CHANGES));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyDetailDefinitionStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailDefinitionStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyDetailDefinitionStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailDefinitionStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_INVALID_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_INVALID_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_INVALID_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_INVALID_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_INVALID_RELATED_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_INVALID_RELATED_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_INVALID_RELATED_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_INVALID_RELATED_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_INVALID_ENTITLEMENT_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_INVALID_ENTITLEMENT_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_INVALID_ENTITLEMENT_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_INVALID_ENTITLEMENT_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_INVALID_ENTITLEMENT_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_INVALID_ENTITLEMENT_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_INVALID_ENTITLEMENT_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_INVALID_ENTITLEMENT_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_INVALID_ENTITLEMENT_ATTRIBUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_INVALID_ENTITLEMENT_ATTRIBUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_INVALID_ENTITLEMENT_ATTRIBUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_INVALID_ENTITLEMENT_ATTRIBUTE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_INVALID_INSTRUMENT_SCOPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_INVALID_INSTRUMENT_SCOPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_INVALID_INSTRUMENT_SCOPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_INVALID_INSTRUMENT_SCOPE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_INVALID_MARKET_SEGMENT_SCOPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_INVALID_MARKET_SEGMENT_SCOPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_INVALID_MARKET_SEGMENT_SCOPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_INVALID_MARKET_SEGMENT_SCOPE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_INVALID_START_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_INVALID_START_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_INVALID_START_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_INVALID_START_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_INVALID_END_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_INVALID_END_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_INVALID_END_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_INVALID_END_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_INSTRUMENT_SCOPE_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_INSTRUMENT_SCOPE_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_INSTRUMENT_SCOPE_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_INSTRUMENT_SCOPE_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_MARKET_SEGMENT_SCOPE_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_MARKET_SEGMENT_SCOPE_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_MARKET_SEGMENT_SCOPE_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_MARKET_SEGMENT_SCOPE_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_ENTITLEMENT_NOT_APPROVED_FOR_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_ENTITLEMENT_NOT_APPROVED_FOR_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_ENTITLEMENT_NOT_APPROVED_FOR_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_ENTITLEMENT_NOT_APPROVED_FOR_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_ENTITLEMENT_ALREADY_DEFINED_FOR_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_ENTITLEMENT_ALREADY_DEFINED_FOR_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_ENTITLEMENT_ALREADY_DEFINED_FOR_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_ENTITLEMENT_ALREADY_DEFINED_FOR_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_INSTRUMENT_NOT_APPROVED_FOR_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_INSTRUMENT_NOT_APPROVED_FOR_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_INSTRUMENT_NOT_APPROVED_FOR_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_INSTRUMENT_NOT_APPROVED_FOR_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_NOT_AUTHORIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_NOT_AUTHORIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_NOT_AUTHORIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_NOT_AUTHORIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementRequestResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementRequestResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementRequestResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementRequestResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementStatus_ACCEPTED_WITH_CHANGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementStatus_ACCEPTED_WITH_CHANGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementStatus_ACCEPTED_WITH_CHANGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementStatus_ACCEPTED_WITH_CHANGES));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementStatus_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementStatus_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementStatus_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementStatus_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementStatus_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementStatus_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementStatus_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementStatus_REQUESTED));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementStatus_DEFERRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementStatus_DEFERRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementStatus_DEFERRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementStatus_DEFERRED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeMatchAckStatus_RECEIVED_NOT_PROCESSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeMatchAckStatus_RECEIVED_NOT_PROCESSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeMatchAckStatus_RECEIVED_NOT_PROCESSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeMatchAckStatus_RECEIVED_NOT_PROCESSED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeMatchAckStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeMatchAckStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeMatchAckStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeMatchAckStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeMatchAckStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeMatchAckStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeMatchAckStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeMatchAckStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeMatchRejectReason_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeMatchRejectReason_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeMatchRejectReason_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeMatchRejectReason_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeMatchRejectReason_INVALID_PARTY_INFORMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeMatchRejectReason_INVALID_PARTY_INFORMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeMatchRejectReason_INVALID_PARTY_INFORMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeMatchRejectReason_INVALID_PARTY_INFORMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeMatchRejectReason_UNKNOWN_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeMatchRejectReason_UNKNOWN_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeMatchRejectReason_UNKNOWN_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeMatchRejectReason_UNKNOWN_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeMatchRejectReason_UNAUTHORIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeMatchRejectReason_UNAUTHORIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeMatchRejectReason_UNAUTHORIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeMatchRejectReason_UNAUTHORIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeMatchRejectReason_INVALID_TRADE_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeMatchRejectReason_INVALID_TRADE_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeMatchRejectReason_INVALID_TRADE_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeMatchRejectReason_INVALID_TRADE_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeMatchRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeMatchRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeMatchRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeMatchRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceMovementType_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceMovementType_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceMovementType_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceMovementType_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceMovementType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceMovementType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceMovementType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceMovementType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDEvent_INITIAL_BLOCK_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDEvent_INITIAL_BLOCK_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDEvent_INITIAL_BLOCK_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDEvent_INITIAL_BLOCK_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDEvent_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDEvent_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDEvent_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDEvent_ALLOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDEvent_CLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDEvent_CLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDEvent_CLEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDEvent_CLEARING));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDEvent_COMPRESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDEvent_COMPRESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDEvent_COMPRESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDEvent_COMPRESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDEvent_NOVATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDEvent_NOVATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDEvent_NOVATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDEvent_NOVATION));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDEvent_TERMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDEvent_TERMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDEvent_TERMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDEvent_TERMINATION));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDEvent_POST_TRD_VAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDEvent_POST_TRD_VAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDEvent_POST_TRD_VAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDEvent_POST_TRD_VAL));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDSource_UNIQUE_TRANSACTION_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDSource_UNIQUE_TRANSACTION_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDSource_UNIQUE_TRANSACTION_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RegulatoryTradeIDSource_UNIQUE_TRANSACTION_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDType_CURRENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDType_CURRENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDType_CURRENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDType_CURRENT));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDType_PREVIOUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDType_PREVIOUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDType_PREVIOUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDType_PREVIOUS));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDType_BLOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDType_BLOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDType_BLOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDType_BLOCK));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDType_RELATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDType_RELATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDType_RELATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDType_RELATED));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDType_CLEARED_BLOCK_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDType_CLEARED_BLOCK_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDType_CLEARED_BLOCK_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDType_CLEARED_BLOCK_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDType_TRADING_VENUE_TRANSACTION_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDType_TRADING_VENUE_TRANSACTION_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDType_TRADING_VENUE_TRANSACTION_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDType_TRADING_VENUE_TRANSACTION_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingIntention_DO_NOT_INTEND_TO_CLEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingIntention_DO_NOT_INTEND_TO_CLEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingIntention_DO_NOT_INTEND_TO_CLEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingIntention_DO_NOT_INTEND_TO_CLEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingIntention_INTEND_TO_CLEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingIntention_INTEND_TO_CLEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingIntention_INTEND_TO_CLEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingIntention_INTEND_TO_CLEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmationMethod_NON_ELECTRONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmationMethod_NON_ELECTRONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmationMethod_NON_ELECTRONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmationMethod_NON_ELECTRONIC));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmationMethod_ELECTRONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmationMethod_ELECTRONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmationMethod_ELECTRONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmationMethod_ELECTRONIC));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmationMethod_UNCONFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmationMethod_UNCONFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmationMethod_UNCONFIRMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmationMethod_UNCONFIRMED));
  return pyobj;
}


SWIGINTERN int Swig_var_VerificationMethod_NON_ELECTRONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VerificationMethod_NON_ELECTRONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VerificationMethod_NON_ELECTRONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::VerificationMethod_NON_ELECTRONIC));
  return pyobj;
}


SWIGINTERN int Swig_var_VerificationMethod_ELECTRONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VerificationMethod_ELECTRONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VerificationMethod_ELECTRONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::VerificationMethod_ELECTRONIC));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingRequirementException_NO_EXCEPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingRequirementException_NO_EXCEPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingRequirementException_NO_EXCEPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingRequirementException_NO_EXCEPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingRequirementException_EXCEPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingRequirementException_EXCEPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingRequirementException_EXCEPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingRequirementException_EXCEPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingRequirementException_END_USER_EXCEPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingRequirementException_END_USER_EXCEPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingRequirementException_END_USER_EXCEPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingRequirementException_END_USER_EXCEPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingRequirementException_INTER_AFFILIATE_EXCEPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingRequirementException_INTER_AFFILIATE_EXCEPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingRequirementException_INTER_AFFILIATE_EXCEPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingRequirementException_INTER_AFFILIATE_EXCEPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingRequirementException_TREASURY_AFFILIATE_EXCEPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingRequirementException_TREASURY_AFFILIATE_EXCEPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingRequirementException_TREASURY_AFFILIATE_EXCEPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingRequirementException_TREASURY_AFFILIATE_EXCEPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingRequirementException_COOPERATIVE_EXCEPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingRequirementException_COOPERATIVE_EXCEPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingRequirementException_COOPERATIVE_EXCEPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingRequirementException_COOPERATIVE_EXCEPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_IRSDirection_PAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IRSDirection_PAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IRSDirection_PAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IRSDirection_PAY);
  return pyobj;
}


SWIGINTERN int Swig_var_IRSDirection_RCV_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IRSDirection_RCV is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IRSDirection_RCV_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IRSDirection_RCV);
  return pyobj;
}


SWIGINTERN int Swig_var_IRSDirection_NA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IRSDirection_NA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IRSDirection_NA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IRSDirection_NA);
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_RT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_RT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_RT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_RT));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_PET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_PET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_PET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_PET));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_SNAPSHOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_SNAPSHOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_SNAPSHOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_SNAPSHOT));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_RTPET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_RTPET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_RTPET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_RTPET));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_PET_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_PET_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_PET_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_PET_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_RTPET_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_RTPET_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_RTPET_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_RTPET_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_POST_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_POST_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_POST_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_POST_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_VERIFICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_VERIFICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_VERIFICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_VERIFICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_PST_TRD_EVNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_PST_TRD_EVNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_PST_TRD_EVNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_PST_TRD_EVNT));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_PST_TRD_EVNT_RT_REPORTABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_PST_TRD_EVNT_RT_REPORTABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_PST_TRD_EVNT_RT_REPORTABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_PST_TRD_EVNT_RT_REPORTABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_LMTF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_LMTF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_LMTF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_LMTF));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_DATF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_DATF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_DATF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_DATF));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_VOLO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_VOLO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_VOLO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_VOLO));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_FWAF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_FWAF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_FWAF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_FWAF));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_IDAF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_IDAF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_IDAF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_IDAF));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_VOLW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_VOLW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_VOLW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_VOLW));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_FULF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_FULF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_FULF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_FULF));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_FULA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_FULA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_FULA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_FULA));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_FULV_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_FULV is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_FULV_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_FULV));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_FULJ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_FULJ is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_FULJ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_FULJ));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_COAF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_COAF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_COAF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_COAF));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_CHILD_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_CHILD_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_CHILD_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_CHILD_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_ORDER_ROUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_ORDER_ROUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_ORDER_ROUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_ORDER_ROUTE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_SUPPLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_SUPPLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_SUPPLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_SUPPLEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_NEW_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_NEW_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_NEW_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_NEW_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_TRANSACTION_CORRECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_TRANSACTION_CORRECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_TRANSACTION_CORRECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_TRANSACTION_CORRECTION));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_TRANSACTION_MODIFICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_TRANSACTION_MODIFICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_TRANSACTION_MODIFICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_TRANSACTION_MODIFICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_COLLATERAL_UPDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_COLLATERAL_UPDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_COLLATERAL_UPDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_COLLATERAL_UPDATE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_MARGIN_UPDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_MARGIN_UPDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_MARGIN_UPDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_MARGIN_UPDATE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_TRANSACTION_REPORTED_IN_ERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_TRANSACTION_REPORTED_IN_ERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_TRANSACTION_REPORTED_IN_ERROR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_TRANSACTION_REPORTED_IN_ERROR));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryReportType_TERMINATION_EARLY_TERMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryReportType_TERMINATION_EARLY_TERMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryReportType_TERMINATION_EARLY_TERMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryReportType_TERMINATION_EARLY_TERMINATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCollateralization_UNCOLLATERALIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCollateralization_UNCOLLATERALIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCollateralization_UNCOLLATERALIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeCollateralization_UNCOLLATERALIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCollateralization_PARTIALLY_COLLATERALIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCollateralization_PARTIALLY_COLLATERALIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCollateralization_PARTIALLY_COLLATERALIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeCollateralization_PARTIALLY_COLLATERALIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCollateralization_ONE_WAY_COLLATERALLIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCollateralization_ONE_WAY_COLLATERALLIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCollateralization_ONE_WAY_COLLATERALLIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeCollateralization_ONE_WAY_COLLATERALLIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCollateralization_FULLY_COLLATERALIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCollateralization_FULLY_COLLATERALIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCollateralization_FULLY_COLLATERALIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeCollateralization_FULLY_COLLATERALIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCollateralization_NET_EXPOSURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCollateralization_NET_EXPOSURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCollateralization_NET_EXPOSURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeCollateralization_NET_EXPOSURE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_NOVATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_NOVATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_NOVATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_NOVATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_PARTIAL_NOVATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_PARTIAL_NOVATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_PARTIAL_NOVATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_PARTIAL_NOVATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_TRADE_UNWIND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_TRADE_UNWIND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_TRADE_UNWIND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_TRADE_UNWIND));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_PARTIAL_TRADE_UNWIND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_PARTIAL_TRADE_UNWIND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_PARTIAL_TRADE_UNWIND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_PARTIAL_TRADE_UNWIND));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_NETTING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_FULL_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_FULL_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_FULL_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_FULL_NETTING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_PARTIAL_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_PARTIAL_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_PARTIAL_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_PARTIAL_NETTING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_AMENDMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_AMENDMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_AMENDMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_AMENDMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_INCREASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_INCREASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_INCREASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_INCREASE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_CREDIT_EVENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_CREDIT_EVENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_CREDIT_EVENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_CREDIT_EVENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_STRATEGIC_RESTRUCTURING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_STRATEGIC_RESTRUCTURING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_STRATEGIC_RESTRUCTURING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_STRATEGIC_RESTRUCTURING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_SUCCESSION_EVENT_REORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_SUCCESSION_EVENT_REORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_SUCCESSION_EVENT_REORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_SUCCESSION_EVENT_REORGANIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_SUCCESSION_EVENT_RENAMING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_SUCCESSION_EVENT_RENAMING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_SUCCESSION_EVENT_RENAMING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_SUCCESSION_EVENT_RENAMING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_PORTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_PORTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_PORTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_PORTING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_WITHDRAWL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_WITHDRAWL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_WITHDRAWL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_WITHDRAWL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_VOID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_VOID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_VOID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_VOID));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_ACCOUNT_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_ACCOUNT_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_ACCOUNT_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_ACCOUNT_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_GIVE_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_GIVE_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_GIVE_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_GIVE_UP));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_TAKE_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_TAKE_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_TAKE_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_TAKE_UP));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_AVERAGE_PRICING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_AVERAGE_PRICING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_AVERAGE_PRICING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_AVERAGE_PRICING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_REVERSAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_REVERSAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_REVERSAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_REVERSAL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_ALLOC_TRD_POSTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_ALLOC_TRD_POSTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_ALLOC_TRD_POSTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_ALLOC_TRD_POSTING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_CASCADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_CASCADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_CASCADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_CASCADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_DELIVERY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_DELIVERY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_DELIVERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_DELIVERY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_OPTION_ASGN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_OPTION_ASGN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_OPTION_ASGN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_OPTION_ASGN));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_EXPIRATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_EXPIRATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_EXPIRATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_EXPIRATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_MATURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_EQUAL_POS_ADJ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_EQUAL_POS_ADJ is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_EQUAL_POS_ADJ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_EQUAL_POS_ADJ));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_UNEQUAL_POS_ADJ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_UNEQUAL_POS_ADJ is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_UNEQUAL_POS_ADJ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_UNEQUAL_POS_ADJ));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_CORRECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_CORRECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_CORRECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_CORRECTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_EARLY_TERMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_EARLY_TERMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_EARLY_TERMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_EARLY_TERMINATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_RERATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_RERATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_RERATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_RERATE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContinuation_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContinuation_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContinuation_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContinuation_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetClass_INTEREST_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetClass_INTEREST_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetClass_INTEREST_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetClass_INTEREST_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetClass_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetClass_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetClass_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetClass_CURRENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetClass_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetClass_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetClass_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetClass_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetClass_EQUITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetClass_EQUITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetClass_EQUITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetClass_EQUITY));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetClass_COMMODITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetClass_COMMODITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetClass_COMMODITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetClass_COMMODITY));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetClass_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetClass_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetClass_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetClass_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetClass_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetClass_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetClass_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetClass_CASH));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetClass_DEBT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetClass_DEBT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetClass_DEBT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetClass_DEBT));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetClass_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetClass_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetClass_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetClass_FUND));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetClass_LOAN_FACILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetClass_LOAN_FACILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetClass_LOAN_FACILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetClass_LOAN_FACILITY));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetClass_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetClass_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetClass_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetClass_INDEX));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_METALS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_METALS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_METALS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_METALS));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_BULLION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_BULLION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_BULLION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_BULLION));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_ENERGY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_ENERGY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_ENERGY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_ENERGY));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_COMMODITY_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_COMMODITY_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_COMMODITY_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_COMMODITY_INDEX));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_AGRICULTURAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_AGRICULTURAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_AGRICULTURAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_AGRICULTURAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_ENVIRONMENTAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_ENVIRONMENTAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_ENVIRONMENTAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_ENVIRONMENTAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_FREIGHT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_FREIGHT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_FREIGHT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_FREIGHT));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_FERTILIZER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_FERTILIZER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_FERTILIZER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_FERTILIZER));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_INDUSTRIAL_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_INDUSTRIAL_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_INDUSTRIAL_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_INDUSTRIAL_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_INFLATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_INFLATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_INFLATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_INFLATION));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_PAPER));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_POLYPROPYLENE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_POLYPROPYLENE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_POLYPROPYLENE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_POLYPROPYLENE));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_OFFICIAL_ECONOMIC_STATISTICS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_OFFICIAL_ECONOMIC_STATISTICS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_OFFICIAL_ECONOMIC_STATISTICS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_OFFICIAL_ECONOMIC_STATISTICS));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_SINGLE_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_SINGLE_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_SINGLE_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_SINGLE_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_CREDIT_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_CREDIT_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_CREDIT_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_CREDIT_INDEX));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_INDEX_TRANCHE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_INDEX_TRANCHE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_INDEX_TRANCHE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_INDEX_TRANCHE));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_CREDIT_BASKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_CREDIT_BASKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_CREDIT_BASKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_CREDIT_BASKET));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_BASKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_BASKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_BASKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_BASKET));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_FX_CROSS_RATES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_FX_CROSS_RATES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_FX_CROSS_RATES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_FX_CROSS_RATES));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_FX_EMERGING_MARKETS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_FX_EMERGING_MARKETS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_FX_EMERGING_MARKETS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_FX_EMERGING_MARKETS));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_FX_MAJORS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_FX_MAJORS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_FX_MAJORS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_FX_MAJORS));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_GOVERNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_GOVERNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_GOVERNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_GOVERNMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_AGENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_CORPORATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_CORPORATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_CORPORATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_CORPORATE));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_FINANCING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_FINANCING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_FINANCING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_FINANCING));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_MONEY_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_MONEY_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_MONEY_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_MONEY_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_MORTGAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_MORTGAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_MORTGAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_MORTGAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_MUNICIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_MUNICIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_MUNICIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_MUNICIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_COMMON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_COMMON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_COMMON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_COMMON));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_PREFERRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_PREFERRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_PREFERRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_PREFERRED));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_EQUITY_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_EQUITY_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_EQUITY_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_EQUITY_INDEX));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_EQUITY_BASKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_EQUITY_BASKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_EQUITY_BASKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_EQUITY_BASKET));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_DIVIDEND_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_DIVIDEND_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_DIVIDEND_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_DIVIDEND_INDEX));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_STOCK_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_STOCK_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_STOCK_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_STOCK_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_EXCHANGE_TRADED_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_EXCHANGE_TRADED_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_EXCHANGE_TRADED_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_EXCHANGE_TRADED_FUND));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_VOLATILITY_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_VOLATILITY_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_VOLATILITY_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_VOLATILITY_INDEX));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_MUTUAL_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_MUTUAL_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_MUTUAL_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_MUTUAL_FUND));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_COLLECTIVE_INVESTMENT_VEHICLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_COLLECTIVE_INVESTMENT_VEHICLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_COLLECTIVE_INVESTMENT_VEHICLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_COLLECTIVE_INVESTMENT_VEHICLE));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_INVESTMENT_PROGRAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_INVESTMENT_PROGRAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_INVESTMENT_PROGRAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_INVESTMENT_PROGRAM));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_SPECIALIZED_ACCOUNT_PROGRAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_SPECIALIZED_ACCOUNT_PROGRAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_SPECIALIZED_ACCOUNT_PROGRAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_SPECIALIZED_ACCOUNT_PROGRAM));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_SINGLE_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_SINGLE_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_SINGLE_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_SINGLE_CURRENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_CROSS_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_CROSS_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_CROSS_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_CROSS_CURRENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_TERM_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_TERM_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_TERM_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_TERM_LOAN));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_BRIDGE_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_BRIDGE_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_BRIDGE_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_BRIDGE_LOAN));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_LETTER_OF_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_LETTER_OF_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_LETTER_OF_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_LETTER_OF_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_EXOTIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_EXOTIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_EXOTIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_EXOTIC));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_OTHER_C10_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_OTHER_C10 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_OTHER_C10_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_OTHER_C10));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetSubClass_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetSubClass_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetSubClass_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetSubClass_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_SwapClass_BASIS_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SwapClass_BASIS_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SwapClass_BASIS_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SwapClass_BASIS_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SwapClass_INDEX_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SwapClass_INDEX_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SwapClass_INDEX_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SwapClass_INDEX_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SwapClass_BROAD_BASED_SECURITY_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SwapClass_BROAD_BASED_SECURITY_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SwapClass_BROAD_BASED_SECURITY_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SwapClass_BROAD_BASED_SECURITY_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SwapClass_BASKET_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SwapClass_BASKET_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SwapClass_BASKET_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SwapClass_BASKET_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_CouponType_ZERO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponType_ZERO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponType_ZERO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponType_ZERO));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponType_FIXED_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponType_FIXED_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponType_FIXED_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponType_FIXED_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponType_FLOATING_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponType_FLOATING_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponType_FLOATING_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponType_FLOATING_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponType_STRUCTURED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponType_STRUCTURED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponType_STRUCTURED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponType_STRUCTURED));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponFrequencyUnit_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponFrequencyUnit_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponFrequencyUnit_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CouponFrequencyUnit_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_CouponFrequencyUnit_WEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponFrequencyUnit_WEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponFrequencyUnit_WEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CouponFrequencyUnit_WEEK);
  return pyobj;
}


SWIGINTERN int Swig_var_CouponFrequencyUnit_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponFrequencyUnit_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponFrequencyUnit_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CouponFrequencyUnit_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_CouponFrequencyUnit_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponFrequencyUnit_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponFrequencyUnit_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CouponFrequencyUnit_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_CouponFrequencyUnit_HOUR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponFrequencyUnit_HOUR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponFrequencyUnit_HOUR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CouponFrequencyUnit_HOUR);
  return pyobj;
}


SWIGINTERN int Swig_var_CouponFrequencyUnit_MINUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponFrequencyUnit_MINUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponFrequencyUnit_MINUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CouponFrequencyUnit_MINUTE);
  return pyobj;
}


SWIGINTERN int Swig_var_CouponFrequencyUnit_SECOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponFrequencyUnit_SECOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponFrequencyUnit_SECOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CouponFrequencyUnit_SECOND);
  return pyobj;
}


SWIGINTERN int Swig_var_CouponFrequencyUnit_TERM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponFrequencyUnit_TERM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponFrequencyUnit_TERM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CouponFrequencyUnit_TERM);
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_ONE_ONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_ONE_ONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_ONE_ONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_ONE_ONE));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_US_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_THIRTY_THREE_SIXTY_US is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_US_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_THIRTY_THREE_SIXTY_US));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_SIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_THIRTY_THREE_SIXTY_SIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_SIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_THIRTY_THREE_SIXTY_SIA));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_M_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_THIRTY_THREE_SIXTY_M is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_M_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_THIRTY_THREE_SIXTY_M));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_THIRTY_E_THREE_SIXTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_THIRTY_E_THREE_SIXTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_THIRTY_E_THREE_SIXTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_THIRTY_E_THREE_SIXTY));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_THIRTY_E_THREE_SIXTY_ISDA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_THIRTY_E_THREE_SIXTY_ISDA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_THIRTY_E_THREE_SIXTY_ISDA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_THIRTY_E_THREE_SIXTY_ISDA));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_ACT_THREE_SIXTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_ACT_THREE_SIXTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_ACT_THREE_SIXTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_ACT_THREE_SIXTY));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_ACT_THREE_SIXTY_FIVE_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_ACT_THREE_SIXTY_FIVE_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_ACT_THREE_SIXTY_FIVE_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_ACT_THREE_SIXTY_FIVE_FIXED));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_ACT_ACT_AFB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_ACT_ACT_AFB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_ACT_ACT_AFB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_ACT_ACT_AFB));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_ACT_ACT_ICMA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_ACT_ACT_ICMA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_ACT_ACT_ICMA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_ACT_ACT_ICMA));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_ACT_ACT_ISMA_ULTIMO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_ACT_ACT_ISMA_ULTIMO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_ACT_ACT_ISMA_ULTIMO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_ACT_ACT_ISMA_ULTIMO));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_ACT_ACT_ISDA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_ACT_ACT_ISDA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_ACT_ACT_ISDA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_ACT_ACT_ISDA));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_BUS_TWO_FIFTY_TWO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_BUS_TWO_FIFTY_TWO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_BUS_TWO_FIFTY_TWO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_BUS_TWO_FIFTY_TWO));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_THIRTY_E_PLUS_THREE_SIXTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_THIRTY_E_PLUS_THREE_SIXTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_THIRTY_E_PLUS_THREE_SIXTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_THIRTY_E_PLUS_THREE_SIXTY));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_ACT_THREE_SIXTY_FIVE_L_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_ACT_THREE_SIXTY_FIVE_L is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_ACT_THREE_SIXTY_FIVE_L_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_ACT_THREE_SIXTY_FIVE_L));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_NL_THREE_SIXTY_FIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_NL_THREE_SIXTY_FIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_NL_THREE_SIXTY_FIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_NL_THREE_SIXTY_FIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_NL_THREE_SIXTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_NL_THREE_SIXTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_NL_THREE_SIXTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_NL_THREE_SIXTY));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_ACT364_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_ACT364 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_ACT364_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_ACT364));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_FIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_THIRTY_THREE_SIXTY_FIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_FIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_THIRTY_THREE_SIXTY_FIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_THIRTY_ACTUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_THIRTY_ACTUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_THIRTY_ACTUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_THIRTY_ACTUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_ICMA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_THIRTY_THREE_SIXTY_ICMA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_ICMA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_THIRTY_THREE_SIXTY_ICMA));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_THIRTY_E_TWO_THREE_SIXTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_THIRTY_E_TWO_THREE_SIXTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_THIRTY_E_TWO_THREE_SIXTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_THIRTY_E_TWO_THREE_SIXTY));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_THIRTY_E_THREE_THREE_SIXTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_THIRTY_E_THREE_THREE_SIXTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_THIRTY_E_THREE_THREE_SIXTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_THIRTY_E_THREE_THREE_SIXTY));
  return pyobj;
}


SWIGINTERN int Swig_var_CouponDayCount_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CouponDayCount_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CouponDayCount_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CouponDayCount_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_LienSeniority_UNKNOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LienSeniority_UNKNOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LienSeniority_UNKNOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LienSeniority_UNKNOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_LienSeniority_FIRST_LIEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LienSeniority_FIRST_LIEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LienSeniority_FIRST_LIEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LienSeniority_FIRST_LIEN));
  return pyobj;
}


SWIGINTERN int Swig_var_LienSeniority_SECOND_LIEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LienSeniority_SECOND_LIEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LienSeniority_SECOND_LIEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LienSeniority_SECOND_LIEN));
  return pyobj;
}


SWIGINTERN int Swig_var_LienSeniority_THIRD_LIEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LienSeniority_THIRD_LIEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LienSeniority_THIRD_LIEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LienSeniority_THIRD_LIEN));
  return pyobj;
}


SWIGINTERN int Swig_var_LoanFacility_BRIDGE_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LoanFacility_BRIDGE_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LoanFacility_BRIDGE_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LoanFacility_BRIDGE_LOAN));
  return pyobj;
}


SWIGINTERN int Swig_var_LoanFacility_LETTER_OF_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LoanFacility_LETTER_OF_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LoanFacility_LETTER_OF_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LoanFacility_LETTER_OF_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_LoanFacility_REVOLVING_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LoanFacility_REVOLVING_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LoanFacility_REVOLVING_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LoanFacility_REVOLVING_LOAN));
  return pyobj;
}


SWIGINTERN int Swig_var_LoanFacility_SWINGLINE_FUNDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LoanFacility_SWINGLINE_FUNDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LoanFacility_SWINGLINE_FUNDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LoanFacility_SWINGLINE_FUNDING));
  return pyobj;
}


SWIGINTERN int Swig_var_LoanFacility_TERM_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LoanFacility_TERM_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LoanFacility_TERM_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LoanFacility_TERM_LOAN));
  return pyobj;
}


SWIGINTERN int Swig_var_LoanFacility_TRADE_CLAIM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LoanFacility_TRADE_CLAIM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LoanFacility_TRADE_CLAIM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LoanFacility_TRADE_CLAIM));
  return pyobj;
}


SWIGINTERN int Swig_var_ReferenceEntityType_ASIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReferenceEntityType_ASIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReferenceEntityType_ASIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReferenceEntityType_ASIAN));
  return pyobj;
}


SWIGINTERN int Swig_var_ReferenceEntityType_AUSTRALIAN_NEW_ZEALAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReferenceEntityType_AUSTRALIAN_NEW_ZEALAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReferenceEntityType_AUSTRALIAN_NEW_ZEALAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReferenceEntityType_AUSTRALIAN_NEW_ZEALAND));
  return pyobj;
}


SWIGINTERN int Swig_var_ReferenceEntityType_EUROPEAN_EMERGING_MARKETS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReferenceEntityType_EUROPEAN_EMERGING_MARKETS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReferenceEntityType_EUROPEAN_EMERGING_MARKETS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReferenceEntityType_EUROPEAN_EMERGING_MARKETS));
  return pyobj;
}


SWIGINTERN int Swig_var_ReferenceEntityType_JAPANESE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReferenceEntityType_JAPANESE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReferenceEntityType_JAPANESE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReferenceEntityType_JAPANESE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReferenceEntityType_NORTH_AMERICAN_HIGH_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReferenceEntityType_NORTH_AMERICAN_HIGH_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReferenceEntityType_NORTH_AMERICAN_HIGH_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReferenceEntityType_NORTH_AMERICAN_HIGH_YIELD));
  return pyobj;
}


SWIGINTERN int Swig_var_ReferenceEntityType_NORTH_AMERICAN_INSURANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReferenceEntityType_NORTH_AMERICAN_INSURANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReferenceEntityType_NORTH_AMERICAN_INSURANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReferenceEntityType_NORTH_AMERICAN_INSURANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReferenceEntityType_NORTH_AMERICAN_INVESTMENT_GRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReferenceEntityType_NORTH_AMERICAN_INVESTMENT_GRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReferenceEntityType_NORTH_AMERICAN_INVESTMENT_GRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReferenceEntityType_NORTH_AMERICAN_INVESTMENT_GRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReferenceEntityType_SINGAPOREAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReferenceEntityType_SINGAPOREAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReferenceEntityType_SINGAPOREAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReferenceEntityType_SINGAPOREAN));
  return pyobj;
}


SWIGINTERN int Swig_var_ReferenceEntityType_WESTERN_EUROPEAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReferenceEntityType_WESTERN_EUROPEAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReferenceEntityType_WESTERN_EUROPEAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReferenceEntityType_WESTERN_EUROPEAN));
  return pyobj;
}


SWIGINTERN int Swig_var_ReferenceEntityType_WESTERN_EUROPEAN_INSURANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReferenceEntityType_WESTERN_EUROPEAN_INSURANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReferenceEntityType_WESTERN_EUROPEAN_INSURANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReferenceEntityType_WESTERN_EUROPEAN_INSURANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_BlockTrdAllocIndicator_BLOCK_TO_BE_ALLOCATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BlockTrdAllocIndicator_BLOCK_TO_BE_ALLOCATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BlockTrdAllocIndicator_BLOCK_TO_BE_ALLOCATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BlockTrdAllocIndicator_BLOCK_TO_BE_ALLOCATED));
  return pyobj;
}


SWIGINTERN int Swig_var_BlockTrdAllocIndicator_BLOCK_NOT_TO_BE_ALLOCATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BlockTrdAllocIndicator_BLOCK_NOT_TO_BE_ALLOCATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BlockTrdAllocIndicator_BLOCK_NOT_TO_BE_ALLOCATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BlockTrdAllocIndicator_BLOCK_NOT_TO_BE_ALLOCATED));
  return pyobj;
}


SWIGINTERN int Swig_var_BlockTrdAllocIndicator_ALLOCATED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BlockTrdAllocIndicator_ALLOCATED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BlockTrdAllocIndicator_ALLOCATED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BlockTrdAllocIndicator_ALLOCATED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingObligationType_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingObligationType_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingObligationType_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnderlyingObligationType_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingObligationType_CONVERTIBLE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingObligationType_CONVERTIBLE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingObligationType_CONVERTIBLE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnderlyingObligationType_CONVERTIBLE_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingObligationType_MORTGAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingObligationType_MORTGAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingObligationType_MORTGAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnderlyingObligationType_MORTGAGE);
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingObligationType_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingObligationType_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingObligationType_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnderlyingObligationType_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_CashSettlQuoteMethod_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashSettlQuoteMethod_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashSettlQuoteMethod_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CashSettlQuoteMethod_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_CashSettlQuoteMethod_MID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashSettlQuoteMethod_MID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashSettlQuoteMethod_MID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CashSettlQuoteMethod_MID));
  return pyobj;
}


SWIGINTERN int Swig_var_CashSettlQuoteMethod_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashSettlQuoteMethod_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashSettlQuoteMethod_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CashSettlQuoteMethod_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_CashSettlValuationMethod_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashSettlValuationMethod_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashSettlValuationMethod_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CashSettlValuationMethod_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_CashSettlValuationMethod_HIGHEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashSettlValuationMethod_HIGHEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashSettlValuationMethod_HIGHEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CashSettlValuationMethod_HIGHEST));
  return pyobj;
}


SWIGINTERN int Swig_var_CashSettlValuationMethod_AVERAGE_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashSettlValuationMethod_AVERAGE_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashSettlValuationMethod_AVERAGE_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CashSettlValuationMethod_AVERAGE_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_CashSettlValuationMethod_AVERAGE_HIGHEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashSettlValuationMethod_AVERAGE_HIGHEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashSettlValuationMethod_AVERAGE_HIGHEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CashSettlValuationMethod_AVERAGE_HIGHEST));
  return pyobj;
}


SWIGINTERN int Swig_var_CashSettlValuationMethod_BLENDED_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashSettlValuationMethod_BLENDED_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashSettlValuationMethod_BLENDED_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CashSettlValuationMethod_BLENDED_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_CashSettlValuationMethod_BLENDED_HIGHEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashSettlValuationMethod_BLENDED_HIGHEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashSettlValuationMethod_BLENDED_HIGHEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CashSettlValuationMethod_BLENDED_HIGHEST));
  return pyobj;
}


SWIGINTERN int Swig_var_CashSettlValuationMethod_AVERAGE_BLENDED_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashSettlValuationMethod_AVERAGE_BLENDED_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashSettlValuationMethod_AVERAGE_BLENDED_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CashSettlValuationMethod_AVERAGE_BLENDED_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_CashSettlValuationMethod_AVERAGE_BLENDED_HIGHEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashSettlValuationMethod_AVERAGE_BLENDED_HIGHEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashSettlValuationMethod_AVERAGE_BLENDED_HIGHEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CashSettlValuationMethod_AVERAGE_BLENDED_HIGHEST));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamType_PAYMENT_CASH_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamType_PAYMENT_CASH_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamType_PAYMENT_CASH_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamType_PAYMENT_CASH_SETTLEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamType_PHYSICAL_DELIVERY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamType_PHYSICAL_DELIVERY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamType_PHYSICAL_DELIVERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamType_PHYSICAL_DELIVERY));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionType_MANDATORY_EARLY_TERMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionType_MANDATORY_EARLY_TERMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionType_MANDATORY_EARLY_TERMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionType_MANDATORY_EARLY_TERMINATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionType_OPTIONAL_EARLY_TERMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionType_OPTIONAL_EARLY_TERMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionType_OPTIONAL_EARLY_TERMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionType_OPTIONAL_EARLY_TERMINATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionType_CANCELABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionType_CANCELABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionType_CANCELABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionType_CANCELABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionType_EXTENDABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionType_EXTENDABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionType_EXTENDABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionType_EXTENDABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionType_MUTUAL_EARLY_TERMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionType_MUTUAL_EARLY_TERMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionType_MUTUAL_EARLY_TERMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionType_MUTUAL_EARLY_TERMINATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionType_EVERGREEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionType_EVERGREEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionType_EVERGREEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionType_EVERGREEN));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionType_CALLABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionType_CALLABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionType_CALLABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionType_CALLABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionType_PUTTABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionType_PUTTABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionType_PUTTABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionType_PUTTABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionDateTenorUnit_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionDateTenorUnit_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionDateTenorUnit_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ProvisionDateTenorUnit_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionDateTenorUnit_WEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionDateTenorUnit_WEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionDateTenorUnit_WEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ProvisionDateTenorUnit_WEEK);
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionDateTenorUnit_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionDateTenorUnit_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionDateTenorUnit_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ProvisionDateTenorUnit_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionDateTenorUnit_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionDateTenorUnit_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionDateTenorUnit_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ProvisionDateTenorUnit_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCalculationAgent_EXERCISING_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCalculationAgent_EXERCISING_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCalculationAgent_EXERCISING_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCalculationAgent_EXERCISING_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCalculationAgent_NON_EXERCISING_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCalculationAgent_NON_EXERCISING_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCalculationAgent_NON_EXERCISING_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCalculationAgent_NON_EXERCISING_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCalculationAgent_MASTER_AGREEENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCalculationAgent_MASTER_AGREEENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCalculationAgent_MASTER_AGREEENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCalculationAgent_MASTER_AGREEENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCalculationAgent_SUPPLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCalculationAgent_SUPPLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCalculationAgent_SUPPLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCalculationAgent_SUPPLEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionOptionSinglePartyBuyerSide_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionOptionSinglePartyBuyerSide_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionOptionSinglePartyBuyerSide_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionOptionSinglePartyBuyerSide_BUY));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionOptionSinglePartyBuyerSide_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionOptionSinglePartyBuyerSide_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionOptionSinglePartyBuyerSide_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionOptionSinglePartyBuyerSide_SELL));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCashSettlMethod_CASH_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCashSettlMethod_CASH_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCashSettlMethod_CASH_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCashSettlMethod_CASH_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCashSettlMethod_CASH_PRICE_ALTERNATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCashSettlMethod_CASH_PRICE_ALTERNATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCashSettlMethod_CASH_PRICE_ALTERNATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCashSettlMethod_CASH_PRICE_ALTERNATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCashSettlMethod_PAR_YIELD_CURVE_ADJUSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCashSettlMethod_PAR_YIELD_CURVE_ADJUSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCashSettlMethod_PAR_YIELD_CURVE_ADJUSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCashSettlMethod_PAR_YIELD_CURVE_ADJUSTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCashSettlMethod_ZERO_COUPON_YIELD_CURVE_ADJUSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCashSettlMethod_ZERO_COUPON_YIELD_CURVE_ADJUSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCashSettlMethod_ZERO_COUPON_YIELD_CURVE_ADJUSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCashSettlMethod_ZERO_COUPON_YIELD_CURVE_ADJUSTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCashSettlMethod_PAR_YIELD_CURVE_UNADJUSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCashSettlMethod_PAR_YIELD_CURVE_UNADJUSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCashSettlMethod_PAR_YIELD_CURVE_UNADJUSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCashSettlMethod_PAR_YIELD_CURVE_UNADJUSTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCashSettlMethod_CROSS_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCashSettlMethod_CROSS_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCashSettlMethod_CROSS_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCashSettlMethod_CROSS_CURRENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCashSettlMethod_COLLATERALIZED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCashSettlMethod_COLLATERALIZED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCashSettlMethod_COLLATERALIZED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCashSettlMethod_COLLATERALIZED_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCashSettlQuoteType_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCashSettlQuoteType_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCashSettlQuoteType_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCashSettlQuoteType_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCashSettlQuoteType_MID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCashSettlQuoteType_MID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCashSettlQuoteType_MID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCashSettlQuoteType_MID));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCashSettlQuoteType_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCashSettlQuoteType_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCashSettlQuoteType_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCashSettlQuoteType_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCashSettlQuoteType_EXERCISING_PARTY_PAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCashSettlQuoteType_EXERCISING_PARTY_PAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCashSettlQuoteType_EXERCISING_PARTY_PAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCashSettlQuoteType_EXERCISING_PARTY_PAYS));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionOptionExerciseEarliestDateOffsetUnit_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ProvisionOptionExerciseEarliestDateOffsetUnit_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_WEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionOptionExerciseEarliestDateOffsetUnit_WEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_WEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ProvisionOptionExerciseEarliestDateOffsetUnit_WEEK);
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionOptionExerciseEarliestDateOffsetUnit_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ProvisionOptionExerciseEarliestDateOffsetUnit_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionOptionExerciseEarliestDateOffsetUnit_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ProvisionOptionExerciseEarliestDateOffsetUnit_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionOptionExerciseFixedDateType_UNADJUSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionOptionExerciseFixedDateType_UNADJUSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionOptionExerciseFixedDateType_UNADJUSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionOptionExerciseFixedDateType_UNADJUSTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionOptionExerciseFixedDateType_ADJUSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionOptionExerciseFixedDateType_ADJUSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionOptionExerciseFixedDateType_ADJUSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionOptionExerciseFixedDateType_ADJUSTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCashSettlPaymentDateType_UNADJUSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCashSettlPaymentDateType_UNADJUSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCashSettlPaymentDateType_UNADJUSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCashSettlPaymentDateType_UNADJUSTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionCashSettlPaymentDateType_ADJUSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionCashSettlPaymentDateType_ADJUSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionCashSettlPaymentDateType_ADJUSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionCashSettlPaymentDateType_ADJUSTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ProtectionTermEventUnit_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProtectionTermEventUnit_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProtectionTermEventUnit_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ProtectionTermEventUnit_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_ProtectionTermEventUnit_WEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProtectionTermEventUnit_WEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProtectionTermEventUnit_WEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ProtectionTermEventUnit_WEEK);
  return pyobj;
}


SWIGINTERN int Swig_var_ProtectionTermEventUnit_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProtectionTermEventUnit_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProtectionTermEventUnit_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ProtectionTermEventUnit_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_ProtectionTermEventUnit_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProtectionTermEventUnit_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProtectionTermEventUnit_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ProtectionTermEventUnit_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_ProtectionTermEventDayType_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProtectionTermEventDayType_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProtectionTermEventDayType_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProtectionTermEventDayType_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_ProtectionTermEventDayType_CALENDAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProtectionTermEventDayType_CALENDAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProtectionTermEventDayType_CALENDAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProtectionTermEventDayType_CALENDAR));
  return pyobj;
}


SWIGINTERN int Swig_var_ProtectionTermEventDayType_COMMODITY_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProtectionTermEventDayType_COMMODITY_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProtectionTermEventDayType_COMMODITY_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProtectionTermEventDayType_COMMODITY_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_ProtectionTermEventDayType_CURRENCY_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProtectionTermEventDayType_CURRENCY_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProtectionTermEventDayType_CURRENCY_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProtectionTermEventDayType_CURRENCY_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_ProtectionTermEventDayType_EXCHANGE_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProtectionTermEventDayType_EXCHANGE_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProtectionTermEventDayType_EXCHANGE_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProtectionTermEventDayType_EXCHANGE_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_ProtectionTermEventDayType_SCHEDULED_TRADING_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProtectionTermEventDayType_SCHEDULED_TRADING_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProtectionTermEventDayType_SCHEDULED_TRADING_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProtectionTermEventDayType_SCHEDULED_TRADING_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_ProtectionTermEventQualifier_RESTRUCTURING_MULTIPLE_HOLDING_OBLIGATIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProtectionTermEventQualifier_RESTRUCTURING_MULTIPLE_HOLDING_OBLIGATIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProtectionTermEventQualifier_RESTRUCTURING_MULTIPLE_HOLDING_OBLIGATIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProtectionTermEventQualifier_RESTRUCTURING_MULTIPLE_HOLDING_OBLIGATIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ProtectionTermEventQualifier_RESTRUCTURING_MULTIPLE_CREDIT_EVENT_NOTICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProtectionTermEventQualifier_RESTRUCTURING_MULTIPLE_CREDIT_EVENT_NOTICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProtectionTermEventQualifier_RESTRUCTURING_MULTIPLE_CREDIT_EVENT_NOTICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProtectionTermEventQualifier_RESTRUCTURING_MULTIPLE_CREDIT_EVENT_NOTICES));
  return pyobj;
}


SWIGINTERN int Swig_var_ProtectionTermEventQualifier_FLOATING_RATE_INTEREST_SHORTFALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProtectionTermEventQualifier_FLOATING_RATE_INTEREST_SHORTFALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProtectionTermEventQualifier_FLOATING_RATE_INTEREST_SHORTFALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProtectionTermEventQualifier_FLOATING_RATE_INTEREST_SHORTFALL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_BROKERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_BROKERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_BROKERAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_BROKERAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_UPFRONT_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_UPFRONT_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_UPFRONT_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_UPFRONT_FEE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_INDEPENDENT_AMOUNT_COLLATERAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_INDEPENDENT_AMOUNT_COLLATERAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_INDEPENDENT_AMOUNT_COLLATERAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_INDEPENDENT_AMOUNT_COLLATERAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_PRINCIPAL_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_PRINCIPAL_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_PRINCIPAL_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_PRINCIPAL_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_NOVATION_TERMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_NOVATION_TERMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_NOVATION_TERMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_NOVATION_TERMINATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_EARLY_TERMINATION_PROVISION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_EARLY_TERMINATION_PROVISION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_EARLY_TERMINATION_PROVISION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_EARLY_TERMINATION_PROVISION));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_CANCELABLE_PROVISION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_CANCELABLE_PROVISION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_CANCELABLE_PROVISION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_CANCELABLE_PROVISION));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_EXTENDIBLE_PROVISION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_EXTENDIBLE_PROVISION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_EXTENDIBLE_PROVISION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_EXTENDIBLE_PROVISION));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_CAP_RATE_PROVISION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_CAP_RATE_PROVISION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_CAP_RATE_PROVISION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_CAP_RATE_PROVISION));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_FLOOR_RATE_PROVISION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_FLOOR_RATE_PROVISION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_FLOOR_RATE_PROVISION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_FLOOR_RATE_PROVISION));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_OPTION_PREMIUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_OPTION_PREMIUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_OPTION_PREMIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_OPTION_PREMIUM));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_SETTLEMENT_PAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_SETTLEMENT_PAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_SETTLEMENT_PAYMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_SETTLEMENT_PAYMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_CASH_SETTL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_CASH_SETTL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_CASH_SETTL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_CASH_SETTL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_SECURITY_LENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_SECURITY_LENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_SECURITY_LENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_SECURITY_LENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_REBATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_REBATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_REBATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_REBATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentPaySide_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentPaySide_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentPaySide_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentPaySide_BUY));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentPaySide_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentPaySide_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentPaySide_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentPaySide_SELL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentSettlStyle_STANDARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentSettlStyle_STANDARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentSettlStyle_STANDARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentSettlStyle_STANDARD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentSettlStyle_NET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentSettlStyle_NET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentSettlStyle_NET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentSettlStyle_NET));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentSettlStyle_STANDARDF_NET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentSettlStyle_STANDARDF_NET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentSettlStyle_STANDARDF_NET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentSettlStyle_STANDARDF_NET));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamType_PERIODIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamType_PERIODIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamType_PERIODIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamType_PERIODIC));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamType_INITIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamType_INITIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamType_INITIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamType_INITIAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamType_SINGLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamType_SINGLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamType_SINGLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamType_SINGLE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamType_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamType_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamType_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamType_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamType_INTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamType_INTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamType_INTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamType_INTEREST));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamType_DIVIDEND_RETURN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamType_DIVIDEND_RETURN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamType_DIVIDEND_RETURN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamType_DIVIDEND_RETURN));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamType_PRICE_RETURN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamType_PRICE_RETURN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamType_PRICE_RETURN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamType_PRICE_RETURN));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamType_TOTAL_RETURN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamType_TOTAL_RETURN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamType_TOTAL_RETURN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamType_TOTAL_RETURN));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamType_VARIANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamType_VARIANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamType_VARIANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamType_VARIANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamType_CORRELATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamType_CORRELATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamType_CORRELATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamType_CORRELATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamDiscountType_STANDARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamDiscountType_STANDARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamDiscountType_STANDARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamDiscountType_STANDARD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamDiscountType_FRA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamDiscountType_FRA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamDiscountType_FRA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamDiscountType_FRA));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamCompoundingMethod_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamCompoundingMethod_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamCompoundingMethod_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamCompoundingMethod_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamCompoundingMethod_FLAT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamCompoundingMethod_FLAT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamCompoundingMethod_FLAT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamCompoundingMethod_FLAT));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamCompoundingMethod_STRAIGHT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamCompoundingMethod_STRAIGHT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamCompoundingMethod_STRAIGHT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamCompoundingMethod_STRAIGHT));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamCompoundingMethod_SPREAD_EXCLUSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamCompoundingMethod_SPREAD_EXCLUSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamCompoundingMethod_SPREAD_EXCLUSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamCompoundingMethod_SPREAD_EXCLUSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentFrequencyUnit_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentFrequencyUnit_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentFrequencyUnit_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamPaymentFrequencyUnit_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentFrequencyUnit_WEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentFrequencyUnit_WEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentFrequencyUnit_WEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamPaymentFrequencyUnit_WEEK);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentFrequencyUnit_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentFrequencyUnit_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentFrequencyUnit_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamPaymentFrequencyUnit_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentFrequencyUnit_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentFrequencyUnit_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentFrequencyUnit_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamPaymentFrequencyUnit_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentFrequencyUnit_TERM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentFrequencyUnit_TERM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentFrequencyUnit_TERM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamPaymentFrequencyUnit_TERM);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentDateOffsetUnit_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentDateOffsetUnit_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentDateOffsetUnit_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamPaymentDateOffsetUnit_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentDateOffsetUnit_WEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentDateOffsetUnit_WEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentDateOffsetUnit_WEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamPaymentDateOffsetUnit_WEEK);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentDateOffsetUnit_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentDateOffsetUnit_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentDateOffsetUnit_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamPaymentDateOffsetUnit_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentDateOffsetUnit_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentDateOffsetUnit_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentDateOffsetUnit_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamPaymentDateOffsetUnit_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamResetWeeklyRollConvention_MONDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamResetWeeklyRollConvention_MONDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamResetWeeklyRollConvention_MONDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamResetWeeklyRollConvention_MONDAY);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamResetWeeklyRollConvention_TUESDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamResetWeeklyRollConvention_TUESDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamResetWeeklyRollConvention_TUESDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamResetWeeklyRollConvention_TUESDAY);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamResetWeeklyRollConvention_WEDNESDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamResetWeeklyRollConvention_WEDNESDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamResetWeeklyRollConvention_WEDNESDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamResetWeeklyRollConvention_WEDNESDAY);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamResetWeeklyRollConvention_THURSDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamResetWeeklyRollConvention_THURSDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamResetWeeklyRollConvention_THURSDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamResetWeeklyRollConvention_THURSDAY);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamResetWeeklyRollConvention_FRIDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamResetWeeklyRollConvention_FRIDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamResetWeeklyRollConvention_FRIDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamResetWeeklyRollConvention_FRIDAY);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamResetWeeklyRollConvention_SATURDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamResetWeeklyRollConvention_SATURDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamResetWeeklyRollConvention_SATURDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamResetWeeklyRollConvention_SATURDAY);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamResetWeeklyRollConvention_SUNDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamResetWeeklyRollConvention_SUNDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamResetWeeklyRollConvention_SUNDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamResetWeeklyRollConvention_SUNDAY);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRateIndexSource_BLOOMBERG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRateIndexSource_BLOOMBERG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRateIndexSource_BLOOMBERG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamRateIndexSource_BLOOMBERG));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRateIndexSource_REUTERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRateIndexSource_REUTERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRateIndexSource_REUTERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamRateIndexSource_REUTERS));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRateIndexSource_TELERATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRateIndexSource_TELERATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRateIndexSource_TELERATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamRateIndexSource_TELERATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRateIndexSource_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRateIndexSource_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRateIndexSource_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamRateIndexSource_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRateIndexCurveUnit_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRateIndexCurveUnit_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRateIndexCurveUnit_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamRateIndexCurveUnit_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRateIndexCurveUnit_WEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRateIndexCurveUnit_WEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRateIndexCurveUnit_WEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamRateIndexCurveUnit_WEEK);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRateIndexCurveUnit_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRateIndexCurveUnit_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRateIndexCurveUnit_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamRateIndexCurveUnit_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRateIndexCurveUnit_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRateIndexCurveUnit_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRateIndexCurveUnit_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamRateIndexCurveUnit_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRateSpreadPositionType_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRateSpreadPositionType_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRateSpreadPositionType_SHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamRateSpreadPositionType_SHORT));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRateSpreadPositionType_LONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRateSpreadPositionType_LONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRateSpreadPositionType_LONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamRateSpreadPositionType_LONG));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRateTreatment_BOND_EQUIVALENT_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRateTreatment_BOND_EQUIVALENT_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRateTreatment_BOND_EQUIVALENT_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamRateTreatment_BOND_EQUIVALENT_YIELD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRateTreatment_MONEY_MARKET_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRateTreatment_MONEY_MARKET_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRateTreatment_MONEY_MARKET_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamRateTreatment_MONEY_MARKET_YIELD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamCapRateBuySide_BUYER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamCapRateBuySide_BUYER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamCapRateBuySide_BUYER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamCapRateBuySide_BUYER));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamCapRateBuySide_SELLER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamCapRateBuySide_SELLER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamCapRateBuySide_SELLER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamCapRateBuySide_SELLER));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamFloorRateBuySide_BUYER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamFloorRateBuySide_BUYER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamFloorRateBuySide_BUYER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamFloorRateBuySide_BUYER));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamFloorRateBuySide_SELLER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamFloorRateBuySide_SELLER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamFloorRateBuySide_SELLER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamFloorRateBuySide_SELLER));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamAveragingMethod_UNWEIGHTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamAveragingMethod_UNWEIGHTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamAveragingMethod_UNWEIGHTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamAveragingMethod_UNWEIGHTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamAveragingMethod_WEIGHTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamAveragingMethod_WEIGHTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamAveragingMethod_WEIGHTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamAveragingMethod_WEIGHTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamNegativeRateTreatment_ZERO_INTEREST_RATE_METHOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamNegativeRateTreatment_ZERO_INTEREST_RATE_METHOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamNegativeRateTreatment_ZERO_INTEREST_RATE_METHOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamNegativeRateTreatment_ZERO_INTEREST_RATE_METHOD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamNegativeRateTreatment_NEGATIVE_INTEREST_RATE_METHOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamNegativeRateTreatment_NEGATIVE_INTEREST_RATE_METHOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamNegativeRateTreatment_NEGATIVE_INTEREST_RATE_METHOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamNegativeRateTreatment_NEGATIVE_INTEREST_RATE_METHOD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInflationLagUnit_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInflationLagUnit_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInflationLagUnit_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamInflationLagUnit_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInflationLagUnit_WEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInflationLagUnit_WEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInflationLagUnit_WEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamInflationLagUnit_WEEK);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInflationLagUnit_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInflationLagUnit_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInflationLagUnit_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamInflationLagUnit_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInflationLagUnit_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInflationLagUnit_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInflationLagUnit_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PaymentStreamInflationLagUnit_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInflationLagDayType_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInflationLagDayType_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInflationLagDayType_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamInflationLagDayType_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInflationLagDayType_CALENDAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInflationLagDayType_CALENDAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInflationLagDayType_CALENDAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamInflationLagDayType_CALENDAR));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInflationLagDayType_COMMODITY_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInflationLagDayType_COMMODITY_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInflationLagDayType_COMMODITY_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamInflationLagDayType_COMMODITY_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInflationLagDayType_CURRENCY_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInflationLagDayType_CURRENCY_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInflationLagDayType_CURRENCY_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamInflationLagDayType_CURRENCY_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInflationLagDayType_EXCHANGE_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInflationLagDayType_EXCHANGE_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInflationLagDayType_EXCHANGE_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamInflationLagDayType_EXCHANGE_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInflationLagDayType_SCHEDULED_TRADING_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInflationLagDayType_SCHEDULED_TRADING_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInflationLagDayType_SCHEDULED_TRADING_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamInflationLagDayType_SCHEDULED_TRADING_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInflationInterpolationMethod_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInflationInterpolationMethod_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInflationInterpolationMethod_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamInflationInterpolationMethod_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInflationInterpolationMethod_LINEAR_ZERO_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInflationInterpolationMethod_LINEAR_ZERO_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInflationInterpolationMethod_LINEAR_ZERO_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamInflationInterpolationMethod_LINEAR_ZERO_YIELD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamFRADiscounting_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamFRADiscounting_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamFRADiscounting_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamFRADiscounting_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamFRADiscounting_ISDA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamFRADiscounting_ISDA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamFRADiscounting_ISDA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamFRADiscounting_ISDA));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamFRADiscounting_AFMA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamFRADiscounting_AFMA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamFRADiscounting_AFMA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamFRADiscounting_AFMA));
  return pyobj;
}


SWIGINTERN int Swig_var_NonDeliverableFixingDateType_UNADJUSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NonDeliverableFixingDateType_UNADJUSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NonDeliverableFixingDateType_UNADJUSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NonDeliverableFixingDateType_UNADJUSTED));
  return pyobj;
}


SWIGINTERN int Swig_var_NonDeliverableFixingDateType_ADJUSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NonDeliverableFixingDateType_ADJUSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NonDeliverableFixingDateType_ADJUSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NonDeliverableFixingDateType_ADJUSTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_NOTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_NOTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_NOTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_NOTIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_CASH_FLOW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_CASH_FLOW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_CASH_FLOW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_CASH_FLOW));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_FX_LINKED_NOTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_FX_LINKED_NOTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_FX_LINKED_NOTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_FX_LINKED_NOTIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_FIXED_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_FIXED_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_FIXED_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_FIXED_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_FUTURE_VALUE_NOTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_FUTURE_VALUE_NOTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_FUTURE_VALUE_NOTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_FUTURE_VALUE_NOTIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_KNOWN_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_KNOWN_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_KNOWN_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_KNOWN_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_FLOATING_RATE_MULTIPLIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_FLOATING_RATE_MULTIPLIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_FLOATING_RATE_MULTIPLIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_FLOATING_RATE_MULTIPLIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_CAP_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_CAP_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_CAP_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_CAP_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_FLOOR_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_FLOOR_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_FLOOR_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_FLOOR_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_NON_DELIVERABLE_SETTL_PAYMENT_DATES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_NON_DELIVERABLE_SETTL_PAYMENT_DATES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_NON_DELIVERABLE_SETTL_PAYMENT_DATES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_NON_DELIVERABLE_SETTL_PAYMENT_DATES));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_NON_DELIVERABLE_SETTL_CALCULATION_DATES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_NON_DELIVERABLE_SETTL_CALCULATION_DATES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_NON_DELIVERABLE_SETTL_CALCULATION_DATES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_NON_DELIVERABLE_SETTL_CALCULATION_DATES));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_NON_DELIVERABLE_FX_FIXING_DATES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_NON_DELIVERABLE_FX_FIXING_DATES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_NON_DELIVERABLE_FX_FIXING_DATES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_NON_DELIVERABLE_FX_FIXING_DATES));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_SETTL_PERIOD_NOTNL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_SETTL_PERIOD_NOTNL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_SETTL_PERIOD_NOTNL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_SETTL_PERIOD_NOTNL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_SETTL_PERIOD_PX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_SETTL_PERIOD_PX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_SETTL_PERIOD_PX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_SETTL_PERIOD_PX));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_CALC_PERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_CALC_PERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_CALC_PERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_CALC_PERIOD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_RATE_MULTIPLIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_DIVIDEND_ACCRUAL_RATE_MULTIPLIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_RATE_MULTIPLIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_DIVIDEND_ACCRUAL_RATE_MULTIPLIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_RATE_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_DIVIDEND_ACCRUAL_RATE_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_RATE_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_DIVIDEND_ACCRUAL_RATE_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_CAP_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_DIVIDEND_ACCRUAL_CAP_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_CAP_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_DIVIDEND_ACCRUAL_CAP_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_FLOOR_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_DIVIDEND_ACCRUAL_FLOOR_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_FLOOR_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_DIVIDEND_ACCRUAL_FLOOR_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_COMPOUNDING_RATE_MULTIPLIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_COMPOUNDING_RATE_MULTIPLIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_COMPOUNDING_RATE_MULTIPLIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_COMPOUNDING_RATE_MULTIPLIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_COMPOUNDING_RATE_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_COMPOUNDING_RATE_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_COMPOUNDING_RATE_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_COMPOUNDING_RATE_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_COMPOUNDING_CAP_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_COMPOUNDING_CAP_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_COMPOUNDING_CAP_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_COMPOUNDING_CAP_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleType_COMPOUNDING_FLOOR_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleType_COMPOUNDING_FLOOR_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleType_COMPOUNDING_FLOOR_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleType_COMPOUNDING_FLOOR_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleStepRelativeTo_INITIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleStepRelativeTo_INITIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleStepRelativeTo_INITIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleStepRelativeTo_INITIAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentScheduleStepRelativeTo_PREVIOUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentScheduleStepRelativeTo_PREVIOUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentScheduleStepRelativeTo_PREVIOUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentScheduleStepRelativeTo_PREVIOUS));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStubType_INITIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStubType_INITIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStubType_INITIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStubType_INITIAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStubType_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStubType_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStubType_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStubType_FINAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStubType_COMPOUNDING_INITIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStubType_COMPOUNDING_INITIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStubType_COMPOUNDING_INITIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStubType_COMPOUNDING_INITIAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStubType_COMPOUNDING_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStubType_COMPOUNDING_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStubType_COMPOUNDING_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStubType_COMPOUNDING_FINAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStubLength_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStubLength_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStubLength_SHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStubLength_SHORT));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStubLength_LONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStubLength_LONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStubLength_LONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStubLength_LONG));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentDateOffsetDayType_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentDateOffsetDayType_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentDateOffsetDayType_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPaymentDateOffsetDayType_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentDateOffsetDayType_CALENDAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentDateOffsetDayType_CALENDAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentDateOffsetDayType_CALENDAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPaymentDateOffsetDayType_CALENDAR));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentDateOffsetDayType_COMMODITY_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentDateOffsetDayType_COMMODITY_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentDateOffsetDayType_COMMODITY_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPaymentDateOffsetDayType_COMMODITY_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentDateOffsetDayType_CURRENCY_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentDateOffsetDayType_CURRENCY_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentDateOffsetDayType_CURRENCY_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPaymentDateOffsetDayType_CURRENCY_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentDateOffsetDayType_EXCHANGE_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentDateOffsetDayType_EXCHANGE_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentDateOffsetDayType_EXCHANGE_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPaymentDateOffsetDayType_EXCHANGE_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPaymentDateOffsetDayType_SCHEDULED_TRADING_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPaymentDateOffsetDayType_SCHEDULED_TRADING_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPaymentDateOffsetDayType_SCHEDULED_TRADING_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPaymentDateOffsetDayType_SCHEDULED_TRADING_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessDayConvention_NOT_APPLICABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessDayConvention_NOT_APPLICABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessDayConvention_NOT_APPLICABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessDayConvention_NOT_APPLICABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessDayConvention_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessDayConvention_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessDayConvention_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessDayConvention_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessDayConvention_FOLLOWING_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessDayConvention_FOLLOWING_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessDayConvention_FOLLOWING_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessDayConvention_FOLLOWING_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessDayConvention_FLOATING_RATE_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessDayConvention_FLOATING_RATE_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessDayConvention_FLOATING_RATE_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessDayConvention_FLOATING_RATE_NOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessDayConvention_MODIFIED_FOLLOWING_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessDayConvention_MODIFIED_FOLLOWING_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessDayConvention_MODIFIED_FOLLOWING_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessDayConvention_MODIFIED_FOLLOWING_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessDayConvention_PRECEDING_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessDayConvention_PRECEDING_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessDayConvention_PRECEDING_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessDayConvention_PRECEDING_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessDayConvention_MODIFIED_PRECEDING_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessDayConvention_MODIFIED_PRECEDING_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessDayConvention_MODIFIED_PRECEDING_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessDayConvention_MODIFIED_PRECEDING_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessDayConvention_NEAREST_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessDayConvention_NEAREST_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessDayConvention_NEAREST_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessDayConvention_NEAREST_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_FIRST_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_FIRST_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_FIRST_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_FIRST_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_SECOND_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_SECOND_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_SECOND_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_SECOND_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_THIRD_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_THIRD_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_THIRD_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_THIRD_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_FOURTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_FOURTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_FOURTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_FOURTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_FIFTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_FIFTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_FIFTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_FIFTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_SIXTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_SIXTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_SIXTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_SIXTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_SEVENTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_SEVENTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_SEVENTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_SEVENTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_EIGHTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_EIGHTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_EIGHTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_EIGHTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_NINTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_NINTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_NINTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_NINTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_TENTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_TENTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_TENTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_TENTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_ELEVENTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_ELEVENTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_ELEVENTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_ELEVENTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_TWELVTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_TWELVTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_TWELVTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_TWELVTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_THIRTEENTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_THIRTEENTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_THIRTEENTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_THIRTEENTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_FORTEENTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_FORTEENTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_FORTEENTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_FORTEENTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_FIFTEENTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_FIFTEENTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_FIFTEENTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_FIFTEENTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_SIXTEENTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_SIXTEENTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_SIXTEENTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_SIXTEENTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_SEVENTEENTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_SEVENTEENTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_SEVENTEENTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_SEVENTEENTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_EIGHTEENTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_EIGHTEENTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_EIGHTEENTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_EIGHTEENTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_NINETEENTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_NINETEENTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_NINETEENTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_NINETEENTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_TWENTIETH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_TWENTIETH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_TWENTIETH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_TWENTIETH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_TWENTY_FIRST_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_TWENTY_FIRST_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_TWENTY_FIRST_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_TWENTY_FIRST_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_TWENTY_SECOND_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_TWENTY_SECOND_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_TWENTY_SECOND_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_TWENTY_SECOND_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_TWENTY_THIRD_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_TWENTY_THIRD_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_TWENTY_THIRD_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_TWENTY_THIRD_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_TWENTY_FOURTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_TWENTY_FOURTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_TWENTY_FOURTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_TWENTY_FOURTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_TWENTY_FIFTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_TWENTY_FIFTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_TWENTY_FIFTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_TWENTY_FIFTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_TWENTY_SIXTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_TWENTY_SIXTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_TWENTY_SIXTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_TWENTY_SIXTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_TWENTY_SEVENTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_TWENTY_SEVENTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_TWENTY_SEVENTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_TWENTY_SEVENTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_TWENTY_EIGTH_DA28Y_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_TWENTY_EIGTH_DA28Y is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_TWENTY_EIGTH_DA28Y_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_TWENTY_EIGTH_DA28Y);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_TWENTY_NINTH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_TWENTY_NINTH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_TWENTY_NINTH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_TWENTY_NINTH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_THIRTIETH_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_THIRTIETH_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_THIRTIETH_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_THIRTIETH_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_EOM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_EOM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_EOM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_EOM);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_FRN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_FRN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_FRN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_FRN);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_IMM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_IMM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_IMM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_IMM);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_IMMCAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_IMMCAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_IMMCAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_IMMCAD);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_IMMAUD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_IMMAUD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_IMMAUD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_IMMAUD);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_IMMNZD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_IMMNZD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_IMMNZD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_IMMNZD);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_SFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_SFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_SFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_SFE);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_NONE);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_TBILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_TBILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_TBILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_TBILL);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_MON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_MON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_MON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_MON);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_TUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_TUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_TUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_TUE);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_WED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_WED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_WED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_WED);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_THU_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_THU is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_THU_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_THU);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_FRI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_FRI is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_FRI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_FRI);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_SAT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_SAT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_SAT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_SAT);
  return pyobj;
}


SWIGINTERN int Swig_var_DateRollConvention_SUN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DateRollConvention_SUN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DateRollConvention_SUN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DateRollConvention_SUN);
  return pyobj;
}


SWIGINTERN int Swig_var_AttachmentEncodingType_BASE64_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AttachmentEncodingType_BASE64 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AttachmentEncodingType_BASE64_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AttachmentEncodingType_BASE64));
  return pyobj;
}


SWIGINTERN int Swig_var_AttachmentEncodingType_RAW_BINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AttachmentEncodingType_RAW_BINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AttachmentEncodingType_RAW_BINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AttachmentEncodingType_RAW_BINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_NegotiationMethod_AUTO_SPOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NegotiationMethod_AUTO_SPOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NegotiationMethod_AUTO_SPOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NegotiationMethod_AUTO_SPOT));
  return pyobj;
}


SWIGINTERN int Swig_var_NegotiationMethod_NEGOTIATED_SPOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NegotiationMethod_NEGOTIATED_SPOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NegotiationMethod_NEGOTIATED_SPOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NegotiationMethod_NEGOTIATED_SPOT));
  return pyobj;
}


SWIGINTERN int Swig_var_NegotiationMethod_PHONE_SPOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NegotiationMethod_PHONE_SPOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NegotiationMethod_PHONE_SPOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NegotiationMethod_PHONE_SPOT));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPeriodType_ASIAN_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPeriodType_ASIAN_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPeriodType_ASIAN_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPeriodType_ASIAN_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPeriodType_ASIAN_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPeriodType_ASIAN_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPeriodType_ASIAN_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPeriodType_ASIAN_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPeriodType_BARRIER_CAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPeriodType_BARRIER_CAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPeriodType_BARRIER_CAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPeriodType_BARRIER_CAP));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPeriodType_BARRIER_FLOOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPeriodType_BARRIER_FLOOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPeriodType_BARRIER_FLOOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPeriodType_BARRIER_FLOOR));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPeriodType_KNOCK_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPeriodType_KNOCK_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPeriodType_KNOCK_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPeriodType_KNOCK_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPeriodType_KNOCK_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPeriodType_KNOCK_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPeriodType_KNOCK_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPeriodType_KNOCK_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventDateOffsetDayType_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventDateOffsetDayType_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventDateOffsetDayType_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventDateOffsetDayType_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventDateOffsetDayType_CALENDAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventDateOffsetDayType_CALENDAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventDateOffsetDayType_CALENDAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventDateOffsetDayType_CALENDAR));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventDateOffsetDayType_COMMODITY_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventDateOffsetDayType_COMMODITY_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventDateOffsetDayType_COMMODITY_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventDateOffsetDayType_COMMODITY_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventDateOffsetDayType_CURRENCY_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventDateOffsetDayType_CURRENCY_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventDateOffsetDayType_CURRENCY_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventDateOffsetDayType_CURRENCY_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventDateOffsetDayType_EXCHANGE_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventDateOffsetDayType_EXCHANGE_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventDateOffsetDayType_EXCHANGE_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventDateOffsetDayType_EXCHANGE_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventDateOffsetDayType_SCHEDULED_TRADING_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventDateOffsetDayType_SCHEDULED_TRADING_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventDateOffsetDayType_SCHEDULED_TRADING_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventDateOffsetDayType_SCHEDULED_TRADING_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexOptPayoutTime_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexOptPayoutTime_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexOptPayoutTime_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexOptPayoutTime_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexOptPayoutTime_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexOptPayoutTime_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexOptPayoutTime_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexOptPayoutTime_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexOptPayoutTime_OFFICIAL_SETTL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexOptPayoutTime_OFFICIAL_SETTL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexOptPayoutTime_OFFICIAL_SETTL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexOptPayoutTime_OFFICIAL_SETTL));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexOptPayoutTime_VALUATION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexOptPayoutTime_VALUATION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexOptPayoutTime_VALUATION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexOptPayoutTime_VALUATION_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexOptPayoutTime_EXCAHGNE_SETTL_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexOptPayoutTime_EXCAHGNE_SETTL_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexOptPayoutTime_EXCAHGNE_SETTL_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexOptPayoutTime_EXCAHGNE_SETTL_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexOptPayoutTime_DERIVATIVES_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexOptPayoutTime_DERIVATIVES_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexOptPayoutTime_DERIVATIVES_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexOptPayoutTime_DERIVATIVES_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexOptPayoutTime_AS_SPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexOptPayoutTime_AS_SPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexOptPayoutTime_AS_SPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexOptPayoutTime_AS_SPECIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventQuoteBasis_CURRENCY1_PER_CURRENCY2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventQuoteBasis_CURRENCY1_PER_CURRENCY2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventQuoteBasis_CURRENCY1_PER_CURRENCY2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventQuoteBasis_CURRENCY1_PER_CURRENCY2));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventQuoteBasis_CURRENCY2_PER_CURRENCY1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventQuoteBasis_CURRENCY2_PER_CURRENCY1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventQuoteBasis_CURRENCY2_PER_CURRENCY1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventQuoteBasis_CURRENCY2_PER_CURRENCY1));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventCreditEventNotifyingParty_SELLER_NOTIFIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventCreditEventNotifyingParty_SELLER_NOTIFIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventCreditEventNotifyingParty_SELLER_NOTIFIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventCreditEventNotifyingParty_SELLER_NOTIFIES));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventCreditEventNotifyingParty_BUYER_NOTIFIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventCreditEventNotifyingParty_BUYER_NOTIFIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventCreditEventNotifyingParty_BUYER_NOTIFIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventCreditEventNotifyingParty_BUYER_NOTIFIES));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventCreditEventNotifyingParty_SELLER_OR_BUYER_NOTIFIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventCreditEventNotifyingParty_SELLER_OR_BUYER_NOTIFIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventCreditEventNotifyingParty_SELLER_OR_BUYER_NOTIFIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventCreditEventNotifyingParty_SELLER_OR_BUYER_NOTIFIES));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleType_NOTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleType_NOTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleType_NOTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleType_NOTIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleType_DELIVERY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleType_DELIVERY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleType_DELIVERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleType_DELIVERY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleType_PHYSICAL_SETTL_PERIODS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleType_PHYSICAL_SETTL_PERIODS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleType_PHYSICAL_SETTL_PERIODS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleType_PHYSICAL_SETTL_PERIODS));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleToleranceType_ABSOLUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleToleranceType_ABSOLUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleToleranceType_ABSOLUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleToleranceType_ABSOLUTE));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleToleranceType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleToleranceType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleToleranceType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleToleranceType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlFlowType_ALL_TIMES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlFlowType_ALL_TIMES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlFlowType_ALL_TIMES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlFlowType_ALL_TIMES));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlFlowType_ON_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlFlowType_ON_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlFlowType_ON_PEAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlFlowType_ON_PEAK));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlFlowType_OFF_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlFlowType_OFF_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlFlowType_OFF_PEAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlFlowType_OFF_PEAK));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlFlowType_BASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlFlowType_BASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlFlowType_BASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlFlowType_BASE));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlFlowType_BLOCK_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlFlowType_BLOCK_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlFlowType_BLOCK_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlFlowType_BLOCK_HOURS));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlFlowType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlFlowType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlFlowType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlFlowType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlHolidaysProcessingInstruction_DO_NOT_INCLUDE_HOLIDAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlHolidaysProcessingInstruction_DO_NOT_INCLUDE_HOLIDAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlHolidaysProcessingInstruction_DO_NOT_INCLUDE_HOLIDAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlHolidaysProcessingInstruction_DO_NOT_INCLUDE_HOLIDAYS));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlHolidaysProcessingInstruction_INCLUDE_HOLIDAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlHolidaysProcessingInstruction_INCLUDE_HOLIDAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlHolidaysProcessingInstruction_INCLUDE_HOLIDAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlHolidaysProcessingInstruction_INCLUDE_HOLIDAYS));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlDay_MONDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlDay_MONDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlDay_MONDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlDay_MONDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlDay_TUESDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlDay_TUESDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlDay_TUESDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlDay_TUESDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlDay_WEDNESDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlDay_WEDNESDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlDay_WEDNESDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlDay_WEDNESDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlDay_THURSDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlDay_THURSDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlDay_THURSDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlDay_THURSDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlDay_FRIDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlDay_FRIDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlDay_FRIDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlDay_FRIDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlDay_SATURDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlDay_SATURDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlDay_SATURDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlDay_SATURDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlDay_SUNDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlDay_SUNDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlDay_SUNDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlDay_SUNDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlDay_ALL_WEEKDAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlDay_ALL_WEEKDAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlDay_ALL_WEEKDAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlDay_ALL_WEEKDAYS));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlDay_ALL_DAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlDay_ALL_DAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlDay_ALL_DAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlDay_ALL_DAYS));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlDay_ALL_WEEKENDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlDay_ALL_WEEKENDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlDay_ALL_WEEKENDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlDay_ALL_WEEKENDS));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlTimeType_HOUR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlTimeType_HOUR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlTimeType_HOUR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlTimeType_HOUR));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryScheduleSettlTimeType_TIMESTAMP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryScheduleSettlTimeType_TIMESTAMP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryScheduleSettlTimeType_TIMESTAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryScheduleSettlTimeType_TIMESTAMP));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamType_PERIODIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamType_PERIODIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamType_PERIODIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamType_PERIODIC));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamType_INITIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamType_INITIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamType_INITIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamType_INITIAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamType_SINGLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamType_SINGLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamType_SINGLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamType_SINGLE));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamDeliveryRestriction_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamDeliveryRestriction_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamDeliveryRestriction_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamDeliveryRestriction_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamDeliveryRestriction_NON_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamDeliveryRestriction_NON_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamDeliveryRestriction_NON_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamDeliveryRestriction_NON_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamDeliveryRestriction_FORCE_MAJEURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamDeliveryRestriction_FORCE_MAJEURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamDeliveryRestriction_FORCE_MAJEURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamDeliveryRestriction_FORCE_MAJEURE));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamDeliveryRestriction_SYSTEM_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamDeliveryRestriction_SYSTEM_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamDeliveryRestriction_SYSTEM_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamDeliveryRestriction_SYSTEM_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamDeliveryRestriction_UNIT_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamDeliveryRestriction_UNIT_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamDeliveryRestriction_UNIT_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamDeliveryRestriction_UNIT_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamTitleTransferCondition_TRANSFERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamTitleTransferCondition_TRANSFERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamTitleTransferCondition_TRANSFERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamTitleTransferCondition_TRANSFERS));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamTitleTransferCondition_DOES_NOT_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamTitleTransferCondition_DOES_NOT_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamTitleTransferCondition_DOES_NOT_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamTitleTransferCondition_DOES_NOT_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamToleranceOptionSide_BUYER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamToleranceOptionSide_BUYER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamToleranceOptionSide_BUYER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamToleranceOptionSide_BUYER));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamToleranceOptionSide_SELLER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamToleranceOptionSide_SELLER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamToleranceOptionSide_SELLER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamToleranceOptionSide_SELLER));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamElectingPartySide_BUYER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamElectingPartySide_BUYER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamElectingPartySide_BUYER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamElectingPartySide_BUYER));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamElectingPartySide_SELLER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamElectingPartySide_SELLER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamElectingPartySide_SELLER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamElectingPartySide_SELLER));
  return pyobj;
}


SWIGINTERN int Swig_var_SwapSubClass_AMORTIZING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SwapSubClass_AMORTIZING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SwapSubClass_AMORTIZING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SwapSubClass_AMORTIZING);
  return pyobj;
}


SWIGINTERN int Swig_var_SwapSubClass_COMPOUNDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SwapSubClass_COMPOUNDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SwapSubClass_COMPOUNDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SwapSubClass_COMPOUNDING);
  return pyobj;
}


SWIGINTERN int Swig_var_SwapSubClass_CONSTANT_NOTIONAL_SCHEDULE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SwapSubClass_CONSTANT_NOTIONAL_SCHEDULE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SwapSubClass_CONSTANT_NOTIONAL_SCHEDULE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SwapSubClass_CONSTANT_NOTIONAL_SCHEDULE);
  return pyobj;
}


SWIGINTERN int Swig_var_SwapSubClass_ACCRETING_NOTIONAL_SCHEDULE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SwapSubClass_ACCRETING_NOTIONAL_SCHEDULE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SwapSubClass_ACCRETING_NOTIONAL_SCHEDULE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SwapSubClass_ACCRETING_NOTIONAL_SCHEDULE);
  return pyobj;
}


SWIGINTERN int Swig_var_SwapSubClass_CUSTOM_NOTIONAL_SCHEDULE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SwapSubClass_CUSTOM_NOTIONAL_SCHEDULE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SwapSubClass_CUSTOM_NOTIONAL_SCHEDULE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SwapSubClass_CUSTOM_NOTIONAL_SCHEDULE);
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyType_STRADDLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyType_STRADDLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyType_STRADDLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StrategyType_STRADDLE);
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyType_STRANGLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyType_STRANGLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyType_STRANGLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StrategyType_STRANGLE);
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyType_BUTTERFLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyType_BUTTERFLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyType_BUTTERFLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StrategyType_BUTTERFLY);
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyType_CONDOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyType_CONDOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyType_CONDOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StrategyType_CONDOR);
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyType_CALLABLE_INVERSIBLE_SNOWBALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyType_CALLABLE_INVERSIBLE_SNOWBALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyType_CALLABLE_INVERSIBLE_SNOWBALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StrategyType_CALLABLE_INVERSIBLE_SNOWBALL);
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StrategyType_OTHER);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlDisruptionProvision_NEGOTIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDisruptionProvision_NEGOTIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlDisruptionProvision_NEGOTIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDisruptionProvision_NEGOTIATION));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlDisruptionProvision_CANCELLATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDisruptionProvision_CANCELLATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlDisruptionProvision_CANCELLATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDisruptionProvision_CANCELLATION));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionProvision_NOT_APPLICABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionProvision_NOT_APPLICABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionProvision_NOT_APPLICABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionProvision_NOT_APPLICABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionProvision_APPLICABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionProvision_APPLICABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionProvision_APPLICABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionProvision_APPLICABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionProvision_AS_IN_MASTER_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionProvision_AS_IN_MASTER_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionProvision_AS_IN_MASTER_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionProvision_AS_IN_MASTER_AGREEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionProvision_AS_IN_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionProvision_AS_IN_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionProvision_AS_IN_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionProvision_AS_IN_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionFallbackProvision_MASTER_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionFallbackProvision_MASTER_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionFallbackProvision_MASTER_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionFallbackProvision_MASTER_AGREEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionFallbackProvision_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionFallbackProvision_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionFallbackProvision_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionFallbackProvision_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionFallbackUnderlierType_BASKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionFallbackUnderlierType_BASKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionFallbackUnderlierType_BASKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionFallbackUnderlierType_BASKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionFallbackUnderlierType_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionFallbackUnderlierType_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionFallbackUnderlierType_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionFallbackUnderlierType_BOND));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionFallbackUnderlierType_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionFallbackUnderlierType_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionFallbackUnderlierType_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionFallbackUnderlierType_CASH));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionFallbackUnderlierType_COMMODITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionFallbackUnderlierType_COMMODITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionFallbackUnderlierType_COMMODITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionFallbackUnderlierType_COMMODITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionFallbackUnderlierType_CONVERTIBLE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionFallbackUnderlierType_CONVERTIBLE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionFallbackUnderlierType_CONVERTIBLE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionFallbackUnderlierType_CONVERTIBLE_BOND));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionFallbackUnderlierType_EQUITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionFallbackUnderlierType_EQUITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionFallbackUnderlierType_EQUITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionFallbackUnderlierType_EQUITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionFallbackUnderlierType_EXCHANGE_TRADED_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionFallbackUnderlierType_EXCHANGE_TRADED_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionFallbackUnderlierType_EXCHANGE_TRADED_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionFallbackUnderlierType_EXCHANGE_TRADED_FUND));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionFallbackUnderlierType_FUTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionFallbackUnderlierType_FUTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionFallbackUnderlierType_FUTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionFallbackUnderlierType_FUTURE));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionFallbackUnderlierType_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionFallbackUnderlierType_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionFallbackUnderlierType_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionFallbackUnderlierType_INDEX));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionFallbackUnderlierType_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionFallbackUnderlierType_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionFallbackUnderlierType_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionFallbackUnderlierType_LOAN));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionFallbackUnderlierType_MORTGAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionFallbackUnderlierType_MORTGAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionFallbackUnderlierType_MORTGAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionFallbackUnderlierType_MORTGAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketDisruptionFallbackUnderlierType_MUTUAL_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketDisruptionFallbackUnderlierType_MUTUAL_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketDisruptionFallbackUnderlierType_MUTUAL_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketDisruptionFallbackUnderlierType_MUTUAL_FUND));
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseConfirmationMethod_NOT_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseConfirmationMethod_NOT_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseConfirmationMethod_NOT_REQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExerciseConfirmationMethod_NOT_REQUIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseConfirmationMethod_NON_ELECTRONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseConfirmationMethod_NON_ELECTRONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseConfirmationMethod_NON_ELECTRONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExerciseConfirmationMethod_NON_ELECTRONIC));
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseConfirmationMethod_ELECTRONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseConfirmationMethod_ELECTRONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseConfirmationMethod_ELECTRONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExerciseConfirmationMethod_ELECTRONIC));
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseConfirmationMethod_UNKNOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseConfirmationMethod_UNKNOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseConfirmationMethod_UNKNOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExerciseConfirmationMethod_UNKNOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_OptionExerciseDateType_UNADJUSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptionExerciseDateType_UNADJUSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OptionExerciseDateType_UNADJUSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptionExerciseDateType_UNADJUSTED));
  return pyobj;
}


SWIGINTERN int Swig_var_OptionExerciseDateType_ADJUSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptionExerciseDateType_ADJUSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OptionExerciseDateType_ADJUSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptionExerciseDateType_ADJUSTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentDateOffsetDayType_BUSINESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentDateOffsetDayType_BUSINESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentDateOffsetDayType_BUSINESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentDateOffsetDayType_BUSINESS));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentDateOffsetDayType_CALENDAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentDateOffsetDayType_CALENDAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentDateOffsetDayType_CALENDAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentDateOffsetDayType_CALENDAR));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentDateOffsetDayType_COMMODITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentDateOffsetDayType_COMMODITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentDateOffsetDayType_COMMODITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentDateOffsetDayType_COMMODITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentDateOffsetDayType_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentDateOffsetDayType_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentDateOffsetDayType_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentDateOffsetDayType_CURRENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentDateOffsetDayType_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentDateOffsetDayType_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentDateOffsetDayType_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentDateOffsetDayType_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentDateOffsetDayType_SCHEDULED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentDateOffsetDayType_SCHEDULED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentDateOffsetDayType_SCHEDULED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentDateOffsetDayType_SCHEDULED));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentForwardStartType_PREPAID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentForwardStartType_PREPAID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentForwardStartType_PREPAID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentForwardStartType_PREPAID));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentForwardStartType_POSTPAID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentForwardStartType_POSTPAID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentForwardStartType_POSTPAID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentForwardStartType_POSTPAID));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentForwardStartType_VARIABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentForwardStartType_VARIABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentForwardStartType_VARIABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentForwardStartType_VARIABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentForwardStartType_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentForwardStartType_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentForwardStartType_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentForwardStartType_FIXED));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamSettlLevel_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamSettlLevel_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamSettlLevel_AVERAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamSettlLevel_AVERAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamSettlLevel_MAXIMUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamSettlLevel_MAXIMUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamSettlLevel_MAXIMUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamSettlLevel_MAXIMUM));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamSettlLevel_MINIMUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamSettlLevel_MINIMUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamSettlLevel_MINIMUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamSettlLevel_MINIMUM));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamSettlLevel_CUMULATIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamSettlLevel_CUMULATIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamSettlLevel_CUMULATIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamSettlLevel_CUMULATIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRateSpreadType_ABSOLUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRateSpreadType_ABSOLUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRateSpreadType_ABSOLUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamRateSpreadType_ABSOLUTE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRateSpreadType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRateSpreadType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRateSpreadType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamRateSpreadType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPricingDayDistribution_ALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPricingDayDistribution_ALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPricingDayDistribution_ALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPricingDayDistribution_ALL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPricingDayDistribution_FIRST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPricingDayDistribution_FIRST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPricingDayDistribution_FIRST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPricingDayDistribution_FIRST));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPricingDayDistribution_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPricingDayDistribution_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPricingDayDistribution_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPricingDayDistribution_LAST));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPricingDayDistribution_PENULTIMATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPricingDayDistribution_PENULTIMATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPricingDayDistribution_PENULTIMATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPricingDayDistribution_PENULTIMATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPricingDayOfWeek_EVERY_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPricingDayOfWeek_EVERY_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPricingDayOfWeek_EVERY_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPricingDayOfWeek_EVERY_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPricingDayOfWeek_MONDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPricingDayOfWeek_MONDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPricingDayOfWeek_MONDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPricingDayOfWeek_MONDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPricingDayOfWeek_TUESDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPricingDayOfWeek_TUESDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPricingDayOfWeek_TUESDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPricingDayOfWeek_TUESDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPricingDayOfWeek_WEDNESDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPricingDayOfWeek_WEDNESDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPricingDayOfWeek_WEDNESDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPricingDayOfWeek_WEDNESDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPricingDayOfWeek_THURSDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPricingDayOfWeek_THURSDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPricingDayOfWeek_THURSDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPricingDayOfWeek_THURSDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPricingDayOfWeek_FRIDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPricingDayOfWeek_FRIDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPricingDayOfWeek_FRIDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPricingDayOfWeek_FRIDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPricingDayOfWeek_SATURDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPricingDayOfWeek_SATURDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPricingDayOfWeek_SATURDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPricingDayOfWeek_SATURDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamPricingDayOfWeek_SUNDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamPricingDayOfWeek_SUNDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamPricingDayOfWeek_SUNDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamPricingDayOfWeek_SUNDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamCommodityNearbySettlDayUnit_WEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamCommodityNearbySettlDayUnit_WEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamCommodityNearbySettlDayUnit_WEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StreamCommodityNearbySettlDayUnit_WEEK);
  return pyobj;
}


SWIGINTERN int Swig_var_StreamCommodityNearbySettlDayUnit_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamCommodityNearbySettlDayUnit_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamCommodityNearbySettlDayUnit_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StreamCommodityNearbySettlDayUnit_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_StreamCommoditySettlDateRollUnit_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamCommoditySettlDateRollUnit_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamCommoditySettlDateRollUnit_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StreamCommoditySettlDateRollUnit_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_StreamCommodityDataSourceIDType_CITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamCommodityDataSourceIDType_CITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamCommodityDataSourceIDType_CITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamCommodityDataSourceIDType_CITY));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamCommodityDataSourceIDType_AIRPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamCommodityDataSourceIDType_AIRPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamCommodityDataSourceIDType_AIRPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamCommodityDataSourceIDType_AIRPORT));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamCommodityDataSourceIDType_WEATHER_STATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamCommodityDataSourceIDType_WEATHER_STATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamCommodityDataSourceIDType_WEATHER_STATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamCommodityDataSourceIDType_WEATHER_STATION));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamCommodityDataSourceIDType_WEATHER_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamCommodityDataSourceIDType_WEATHER_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamCommodityDataSourceIDType_WEATHER_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamCommodityDataSourceIDType_WEATHER_INDEX));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamNotionalCommodityFrequency_TERM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamNotionalCommodityFrequency_TERM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamNotionalCommodityFrequency_TERM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamNotionalCommodityFrequency_TERM));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamNotionalCommodityFrequency_PER_BUSINESS_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamNotionalCommodityFrequency_PER_BUSINESS_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamNotionalCommodityFrequency_PER_BUSINESS_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamNotionalCommodityFrequency_PER_BUSINESS_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamNotionalCommodityFrequency_PER_CALCULATION_PERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamNotionalCommodityFrequency_PER_CALCULATION_PERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamNotionalCommodityFrequency_PER_CALCULATION_PERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamNotionalCommodityFrequency_PER_CALCULATION_PERIOD));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamNotionalCommodityFrequency_PER_SETTL_PERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamNotionalCommodityFrequency_PER_SETTL_PERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamNotionalCommodityFrequency_PER_SETTL_PERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamNotionalCommodityFrequency_PER_SETTL_PERIOD));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamNotionalCommodityFrequency_PER_CALENDAR_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamNotionalCommodityFrequency_PER_CALENDAR_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamNotionalCommodityFrequency_PER_CALENDAR_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamNotionalCommodityFrequency_PER_CALENDAR_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamNotionalCommodityFrequency_PER_HOUR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamNotionalCommodityFrequency_PER_HOUR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamNotionalCommodityFrequency_PER_HOUR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamNotionalCommodityFrequency_PER_HOUR));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamNotionalCommodityFrequency_PER_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamNotionalCommodityFrequency_PER_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamNotionalCommodityFrequency_PER_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamNotionalCommodityFrequency_PER_MONTH));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitReportStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitReportStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitReportStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitReportStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitReportStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitReportStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitReportStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitReportStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitReportRejectReason_UNK_RISK_LMT_RPRT_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitReportRejectReason_UNK_RISK_LMT_RPRT_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitReportRejectReason_UNK_RISK_LMT_RPRT_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitReportRejectReason_UNK_RISK_LMT_RPRT_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitReportRejectReason_UNK_PTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitReportRejectReason_UNK_PTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitReportRejectReason_UNK_PTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitReportRejectReason_UNK_PTY));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitReportRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitReportRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitReportRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitReportRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckType_SUBMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckType_SUBMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckType_SUBMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckType_SUBMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckType_LIMIT_CONSUMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckType_LIMIT_CONSUMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckType_LIMIT_CONSUMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckType_LIMIT_CONSUMED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckRequestType_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckRequestType_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckRequestType_ALL_OR_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckRequestType_ALL_OR_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckRequestType_PARTIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckRequestType_PARTIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckRequestType_PARTIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckRequestType_PARTIAL));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckRequestStatus_APPROVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckRequestStatus_APPROVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckRequestStatus_APPROVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckRequestStatus_APPROVED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckRequestStatus_PARTIALLY_APPROVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckRequestStatus_PARTIALLY_APPROVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckRequestStatus_PARTIALLY_APPROVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckRequestStatus_PARTIALLY_APPROVED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckRequestStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckRequestStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckRequestStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckRequestStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckRequestStatus_APPROVAL_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckRequestStatus_APPROVAL_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckRequestStatus_APPROVAL_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckRequestStatus_APPROVAL_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckRequestStatus_CANCELLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckRequestStatus_CANCELLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckRequestStatus_CANCELLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckRequestStatus_CANCELLED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckRequestResult_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckRequestResult_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckRequestResult_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckRequestResult_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckRequestResult_INVALID_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckRequestResult_INVALID_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckRequestResult_INVALID_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckRequestResult_INVALID_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckRequestResult_REQ_EXCEEDS_CREDIT_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckRequestResult_REQ_EXCEEDS_CREDIT_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckRequestResult_REQ_EXCEEDS_CREDIT_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckRequestResult_REQ_EXCEEDS_CREDIT_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckRequestResult_REQ_EXCEEDS_CLIP_SIZE_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckRequestResult_REQ_EXCEEDS_CLIP_SIZE_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckRequestResult_REQ_EXCEEDS_CLIP_SIZE_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckRequestResult_REQ_EXCEEDS_CLIP_SIZE_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckRequestResult_REQ_EXCEEDS_MAX_NOTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckRequestResult_REQ_EXCEEDS_MAX_NOTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckRequestResult_REQ_EXCEEDS_MAX_NOTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckRequestResult_REQ_EXCEEDS_MAX_NOTIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckRequestResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckRequestResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckRequestResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckRequestResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyActionType_SUSPEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyActionType_SUSPEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyActionType_SUSPEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyActionType_SUSPEND));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyActionType_HALT_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyActionType_HALT_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyActionType_HALT_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyActionType_HALT_TRADING));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyActionType_REINSTATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyActionType_REINSTATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyActionType_REINSTATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyActionType_REINSTATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyActionResponse_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyActionResponse_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyActionResponse_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyActionResponse_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyActionResponse_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyActionResponse_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyActionResponse_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyActionResponse_COMPLETED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyActionResponse_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyActionResponse_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyActionResponse_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyActionResponse_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyActionRejectReason_INVALID_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyActionRejectReason_INVALID_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyActionRejectReason_INVALID_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyActionRejectReason_INVALID_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyActionRejectReason_UNK_REQ_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyActionRejectReason_UNK_REQ_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyActionRejectReason_UNK_REQ_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyActionRejectReason_UNK_REQ_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyActionRejectReason_NOT_AUTHORIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyActionRejectReason_NOT_AUTHORIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyActionRejectReason_NOT_AUTHORIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyActionRejectReason_NOT_AUTHORIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyActionRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyActionRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyActionRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyActionRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_RefRiskLimitCheckIDType_RISK_LIMIT_REQUEST_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefRiskLimitCheckIDType_RISK_LIMIT_REQUEST_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefRiskLimitCheckIDType_RISK_LIMIT_REQUEST_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RefRiskLimitCheckIDType_RISK_LIMIT_REQUEST_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefRiskLimitCheckIDType_RISK_LIMIT_CHECK_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefRiskLimitCheckIDType_RISK_LIMIT_CHECK_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefRiskLimitCheckIDType_RISK_LIMIT_CHECK_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RefRiskLimitCheckIDType_RISK_LIMIT_CHECK_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefRiskLimitCheckIDType_OUT_OF_BAND_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefRiskLimitCheckIDType_OUT_OF_BAND_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefRiskLimitCheckIDType_OUT_OF_BAND_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RefRiskLimitCheckIDType_OUT_OF_BAND_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckModelType_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckModelType_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckModelType_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckModelType_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckModelType_PLUS_ONE_MODEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckModelType_PLUS_ONE_MODEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckModelType_PLUS_ONE_MODEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckModelType_PLUS_ONE_MODEL));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckModelType_PING_MODEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckModelType_PING_MODEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckModelType_PING_MODEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckModelType_PING_MODEL));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckModelType_PUSH_MODEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckModelType_PUSH_MODEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckModelType_PUSH_MODEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckModelType_PUSH_MODEL));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_CLAIM_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_CLAIM_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_CLAIM_REQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_CLAIM_REQUIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_PRE_DEFINED_LIMIT_CHECK_SUCCEEDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_PRE_DEFINED_LIMIT_CHECK_SUCCEEDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_PRE_DEFINED_LIMIT_CHECK_SUCCEEDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_PRE_DEFINED_LIMIT_CHECK_SUCCEEDED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_PRE_DEFINED_LIMIT_CHECK_FAILED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_PRE_DEFINED_LIMIT_CHECK_FAILED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_PRE_DEFINED_LIMIT_CHECK_FAILED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_PRE_DEFINED_LIMIT_CHECK_FAILED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_PRE_DEFINED_AUTO_ACCEPT_RULE_INVOKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_PRE_DEFINED_AUTO_ACCEPT_RULE_INVOKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_PRE_DEFINED_AUTO_ACCEPT_RULE_INVOKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_PRE_DEFINED_AUTO_ACCEPT_RULE_INVOKED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_PRE_DEFINED_AUTO_REJECT_RULE_INVOKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_PRE_DEFINED_AUTO_REJECT_RULE_INVOKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_PRE_DEFINED_AUTO_REJECT_RULE_INVOKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_PRE_DEFINED_AUTO_REJECT_RULE_INVOKED));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_ACCEPTED_BY_CLEARING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_ACCEPTED_BY_CLEARING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_ACCEPTED_BY_CLEARING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_ACCEPTED_BY_CLEARING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_REJECTED_BY_CLEARING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_REJECTED_BY_CLEARING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_REJECTED_BY_CLEARING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_REJECTED_BY_CLEARING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_ACCEPTED_BY_CREDIT_HUB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_ACCEPTED_BY_CREDIT_HUB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_ACCEPTED_BY_CREDIT_HUB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_ACCEPTED_BY_CREDIT_HUB));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_REJECTED_BY_CREDIT_HUB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_REJECTED_BY_CREDIT_HUB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_REJECTED_BY_CREDIT_HUB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_REJECTED_BY_CREDIT_HUB));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_PENDING_CREDIT_HUB_CHECK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_PENDING_CREDIT_HUB_CHECK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_PENDING_CREDIT_HUB_CHECK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_PENDING_CREDIT_HUB_CHECK));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_ACCEPTED_BY_EXEC_VENUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_ACCEPTED_BY_EXEC_VENUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_ACCEPTED_BY_EXEC_VENUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_ACCEPTED_BY_EXEC_VENUE));
  return pyobj;
}


SWIGINTERN int Swig_var_RiskLimitCheckStatus_REJECTED_BY_EXEC_VENUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitCheckStatus_REJECTED_BY_EXEC_VENUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RiskLimitCheckStatus_REJECTED_BY_EXEC_VENUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitCheckStatus_REJECTED_BY_EXEC_VENUE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTransactionType_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTransactionType_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTransactionType_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTransactionType_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTransactionType_SEF_REQUIRED_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTransactionType_SEF_REQUIRED_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTransactionType_SEF_REQUIRED_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTransactionType_SEF_REQUIRED_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTransactionType_SEF_PERMITTED_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTransactionType_SEF_PERMITTED_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTransactionType_SEF_PERMITTED_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTransactionType_SEF_PERMITTED_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_BatchProcessMode_UPDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BatchProcessMode_UPDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BatchProcessMode_UPDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BatchProcessMode_UPDATE));
  return pyobj;
}


SWIGINTERN int Swig_var_BatchProcessMode_SNAPSHOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BatchProcessMode_SNAPSHOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BatchProcessMode_SNAPSHOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BatchProcessMode_SNAPSHOT));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamDeliveryPointSource_PROPRIETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamDeliveryPointSource_PROPRIETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamDeliveryPointSource_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamDeliveryPointSource_PROPRIETARY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryStreamDeliveryPointSource_EIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryStreamDeliveryPointSource_EIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryStreamDeliveryPointSource_EIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryStreamDeliveryPointSource_EIC));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxonomyType_ISIN_OR_ALT_INSTRMT_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxonomyType_ISIN_OR_ALT_INSTRMT_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxonomyType_ISIN_OR_ALT_INSTRMT_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TaxonomyType_ISIN_OR_ALT_INSTRMT_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxonomyType_INTERIM_TAXONOMY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxonomyType_INTERIM_TAXONOMY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxonomyType_INTERIM_TAXONOMY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TaxonomyType_INTERIM_TAXONOMY));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDScope_CLEARING_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDScope_CLEARING_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDScope_CLEARING_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDScope_CLEARING_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_RegulatoryTradeIDScope_CLIENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegulatoryTradeIDScope_CLIENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegulatoryTradeIDScope_CLIENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegulatoryTradeIDScope_CLIENT));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementSubType_ORDER_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementSubType_ORDER_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementSubType_ORDER_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementSubType_ORDER_ENTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementSubType_H_IT_LIFT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementSubType_H_IT_LIFT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementSubType_H_IT_LIFT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementSubType_H_IT_LIFT));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementSubType_VIEW_INDICATIVE_PX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementSubType_VIEW_INDICATIVE_PX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementSubType_VIEW_INDICATIVE_PX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementSubType_VIEW_INDICATIVE_PX));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementSubType_VIEW_EXECUTABLE_PX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementSubType_VIEW_EXECUTABLE_PX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementSubType_VIEW_EXECUTABLE_PX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementSubType_VIEW_EXECUTABLE_PX));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementSubType_SINGLE_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementSubType_SINGLE_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementSubType_SINGLE_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementSubType_SINGLE_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementSubType_STREAMING_QUOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementSubType_STREAMING_QUOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementSubType_STREAMING_QUOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementSubType_STREAMING_QUOTES));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementSubType_SINGLE_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementSubType_SINGLE_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementSubType_SINGLE_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementSubType_SINGLE_BROKER));
  return pyobj;
}


SWIGINTERN int Swig_var_EntitlementSubType_MULTI_BROKERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EntitlementSubType_MULTI_BROKERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EntitlementSubType_MULTI_BROKERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EntitlementSubType_MULTI_BROKERS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteModelType_QUOTE_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteModelType_QUOTE_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteModelType_QUOTE_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteModelType_QUOTE_ENTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteModelType_QUOTE_MODIFICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteModelType_QUOTE_MODIFICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteModelType_QUOTE_MODIFICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteModelType_QUOTE_MODIFICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecMethod_UNSPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecMethod_UNSPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecMethod_UNSPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecMethod_UNSPECIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecMethod_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecMethod_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecMethod_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecMethod_MANUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecMethod_AUTOMATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecMethod_AUTOMATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecMethod_AUTOMATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecMethod_AUTOMATED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecMethod_VOICE_BROKERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecMethod_VOICE_BROKERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecMethod_VOICE_BROKERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecMethod_VOICE_BROKERED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContingency_DOES_NOT_APPLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContingency_DOES_NOT_APPLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContingency_DOES_NOT_APPLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContingency_DOES_NOT_APPLY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContingency_CONTINGENT_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContingency_CONTINGENT_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContingency_CONTINGENT_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContingency_CONTINGENT_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeContingency_NON_CONTINGENT_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeContingency_NON_CONTINGENT_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeContingency_NON_CONTINGENT_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeContingency_NON_CONTINGENT_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentSubType_INITIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentSubType_INITIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentSubType_INITIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentSubType_INITIAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentSubType_INTERMEDIATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentSubType_INTERMEDIATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentSubType_INTERMEDIATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentSubType_INTERMEDIATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentSubType_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentSubType_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentSubType_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentSubType_FINAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentSubType_PREPAID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentSubType_PREPAID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentSubType_PREPAID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentSubType_PREPAID));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentSubType_POSTPAID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentSubType_POSTPAID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentSubType_POSTPAID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentSubType_POSTPAID));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentSubType_VARIABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentSubType_VARIABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentSubType_VARIABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentSubType_VARIABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentSubType_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentSubType_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentSubType_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentSubType_FIXED));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentSubType_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentSubType_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentSubType_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentSubType_SWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentSubType_CONDITIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentSubType_CONDITIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentSubType_CONDITIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentSubType_CONDITIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentSubType_FIXED_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentSubType_FIXED_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentSubType_FIXED_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentSubType_FIXED_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentSubType_FLOATING_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentSubType_FLOATING_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentSubType_FLOATING_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentSubType_FLOATING_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassOrderRequestStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassOrderRequestStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassOrderRequestStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassOrderRequestStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassOrderRequestStatus_ACCEPTED_WITH_ADDITIONAL_EVENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassOrderRequestStatus_ACCEPTED_WITH_ADDITIONAL_EVENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassOrderRequestStatus_ACCEPTED_WITH_ADDITIONAL_EVENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassOrderRequestStatus_ACCEPTED_WITH_ADDITIONAL_EVENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassOrderRequestStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassOrderRequestStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassOrderRequestStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassOrderRequestStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassOrderRequestResult_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassOrderRequestResult_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassOrderRequestResult_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassOrderRequestResult_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int Swig_var_MassOrderRequestResult_RESPONSE_LEVEL_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassOrderRequestResult_RESPONSE_LEVEL_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassOrderRequestResult_RESPONSE_LEVEL_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassOrderRequestResult_RESPONSE_LEVEL_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassOrderRequestResult_INVALID_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassOrderRequestResult_INVALID_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassOrderRequestResult_INVALID_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassOrderRequestResult_INVALID_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MassOrderRequestResult_INVALID_MARKET_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassOrderRequestResult_INVALID_MARKET_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassOrderRequestResult_INVALID_MARKET_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassOrderRequestResult_INVALID_MARKET_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassOrderRequestResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassOrderRequestResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassOrderRequestResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassOrderRequestResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderResponseLevel_NO_ACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderResponseLevel_NO_ACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderResponseLevel_NO_ACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderResponseLevel_NO_ACK));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderResponseLevel_MINIMUM_ACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderResponseLevel_MINIMUM_ACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderResponseLevel_MINIMUM_ACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderResponseLevel_MINIMUM_ACK));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderResponseLevel_ACK_EACH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderResponseLevel_ACK_EACH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderResponseLevel_ACK_EACH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderResponseLevel_ACK_EACH));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderResponseLevel_SUMMARY_ACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderResponseLevel_SUMMARY_ACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderResponseLevel_SUMMARY_ACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderResponseLevel_SUMMARY_ACK));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEntryAction_ADD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEntryAction_ADD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEntryAction_ADD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderEntryAction_ADD));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEntryAction_MODIFY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEntryAction_MODIFY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEntryAction_MODIFY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderEntryAction_MODIFY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEntryAction_DELETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEntryAction_DELETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEntryAction_DELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderEntryAction_DELETE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEntryAction_SUSPEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEntryAction_SUSPEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEntryAction_SUSPEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderEntryAction_SUSPEND));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderEntryAction_RELEASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderEntryAction_RELEASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderEntryAction_RELEASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderEntryAction_RELEASE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_ORD_ADDED_ON_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_ORD_ADDED_ON_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_ORD_ADDED_ON_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_ORD_ADDED_ON_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_ORD_REPLACED_ON_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_ORD_REPLACED_ON_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_ORD_REPLACED_ON_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_ORD_REPLACED_ON_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_ORD_CXLD_ON_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_ORD_CXLD_ON_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_ORD_CXLD_ON_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_ORD_CXLD_ON_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_UNSOLICITED_ORD_CXL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_UNSOLICITED_ORD_CXL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_UNSOLICITED_ORD_CXL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_UNSOLICITED_ORD_CXL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_NON_RESTING_ORD_ADDED_ON_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_NON_RESTING_ORD_ADDED_ON_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_NON_RESTING_ORD_ADDED_ON_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_NON_RESTING_ORD_ADDED_ON_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_ORD_REPLACED_WITH_NON_RESTING_ORD_ON_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_ORD_REPLACED_WITH_NON_RESTING_ORD_ON_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_ORD_REPLACED_WITH_NON_RESTING_ORD_ON_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_ORD_REPLACED_WITH_NON_RESTING_ORD_ON_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_TRIGGER_ORD_REPLACED_ON_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_TRIGGER_ORD_REPLACED_ON_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_TRIGGER_ORD_REPLACED_ON_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_TRIGGER_ORD_REPLACED_ON_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_SUSPENDED_ORD_REPLACED_ON_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_SUSPENDED_ORD_REPLACED_ON_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_SUSPENDED_ORD_REPLACED_ON_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_SUSPENDED_ORD_REPLACED_ON_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_SUSPENDED_ORD_CXLD_ON_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_SUSPENDED_ORD_CXLD_ON_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_SUSPENDED_ORD_CXLD_ON_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_SUSPENDED_ORD_CXLD_ON_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_ORD_CXL_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_ORD_CXL_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_ORD_CXL_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_ORD_CXL_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_PENDING_CXL_EXECUTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_PENDING_CXL_EXECUTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_PENDING_CXL_EXECUTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_PENDING_CXL_EXECUTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_RESTING_ORD_TRIGGERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_RESTING_ORD_TRIGGERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_RESTING_ORD_TRIGGERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_RESTING_ORD_TRIGGERED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_SUSPENDED_ORD_ACTIVATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_SUSPENDED_ORD_ACTIVATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_SUSPENDED_ORD_ACTIVATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_SUSPENDED_ORD_ACTIVATED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_ACTIVE_ORD_SUSPENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_ACTIVE_ORD_SUSPENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_ACTIVE_ORD_SUSPENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_ACTIVE_ORD_SUSPENDED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTypeReason_ORD_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTypeReason_ORD_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTypeReason_ORD_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecTypeReason_ORD_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferType_REQUEST_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferType_REQUEST_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferType_REQUEST_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferType_REQUEST_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferType_ACCEPT_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferType_ACCEPT_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferType_ACCEPT_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferType_ACCEPT_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferType_DECLINE_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferType_DECLINE_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferType_DECLINE_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferType_DECLINE_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferScope_INTER_FIRM_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferScope_INTER_FIRM_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferScope_INTER_FIRM_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferScope_INTER_FIRM_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferScope_INTRA_FIRM_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferScope_INTRA_FIRM_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferScope_INTRA_FIRM_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferScope_INTRA_FIRM_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferScope_CMTA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferScope_CMTA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferScope_CMTA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferScope_CMTA));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferStatus_REJECTED_BY_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferStatus_REJECTED_BY_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferStatus_REJECTED_BY_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferStatus_REJECTED_BY_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferStatus_ACCEPT_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferStatus_ACCEPT_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferStatus_ACCEPT_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferStatus_ACCEPT_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferStatus_DECLINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferStatus_DECLINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferStatus_DECLINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferStatus_DECLINED));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferStatus_CANCELLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferStatus_CANCELLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferStatus_CANCELLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferStatus_CANCELLED));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferRejectReason_SUCCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferRejectReason_SUCCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferRejectReason_SUCCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferRejectReason_SUCCESS));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferRejectReason_INVALID_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferRejectReason_INVALID_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferRejectReason_INVALID_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferRejectReason_INVALID_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferRejectReason_UNKNOWN_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferRejectReason_UNKNOWN_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferRejectReason_UNKNOWN_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferRejectReason_UNKNOWN_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferRejectReason_UNAUTHORIZED_TO_SUBMIT_XFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferRejectReason_UNAUTHORIZED_TO_SUBMIT_XFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferRejectReason_UNAUTHORIZED_TO_SUBMIT_XFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferRejectReason_UNAUTHORIZED_TO_SUBMIT_XFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferRejectReason_UNKNOWN_POSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferRejectReason_UNKNOWN_POSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferRejectReason_UNKNOWN_POSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferRejectReason_UNKNOWN_POSITION));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferReportType_SUBMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferReportType_SUBMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferReportType_SUBMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferReportType_SUBMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_TransferReportType_ALLEGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransferReportType_ALLEGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransferReportType_ALLEGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransferReportType_ALLEGED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_COUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_COUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_COUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_COUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_AVERAGE_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_AVERAGE_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_AVERAGE_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_AVERAGE_VOLUME));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_TOTAL_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_TOTAL_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_TOTAL_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_TOTAL_VOLUME));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_DISTRIBUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_DISTRIBUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_DISTRIBUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_DISTRIBUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_RATIO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_RATIO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_RATIO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_RATIO));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_LIQUIDITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_LIQUIDITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_LIQUIDITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_LIQUIDITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_VWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_VOLATILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_VOLATILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_VOLATILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_VOLATILITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_DURATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_DURATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_DURATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_DURATION));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_TICK));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_AVERAGE_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_AVERAGE_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_AVERAGE_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_AVERAGE_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_TOTAL_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_TOTAL_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_TOTAL_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_TOTAL_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_HIGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_HIGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_HIGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_HIGH));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_LOW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_LOW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_LOW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_LOW));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_MIDPOINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_MIDPOINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_MIDPOINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_MIDPOINT));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_FIRST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_FIRST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_FIRST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_FIRST));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_LAST));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_FINAL));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_EXCHANGE_BEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_EXCHANGE_BEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_EXCHANGE_BEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_EXCHANGE_BEST));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_EXCHANGE_BEST_WITH_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_EXCHANGE_BEST_WITH_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_EXCHANGE_BEST_WITH_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_EXCHANGE_BEST_WITH_VOLUME));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_CONSOLIDATED_BEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_CONSOLIDATED_BEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_CONSOLIDATED_BEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_CONSOLIDATED_BEST));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_CONSOLIDATED_BEST_WITH_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_CONSOLIDATED_BEST_WITH_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_CONSOLIDATED_BEST_WITH_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_CONSOLIDATED_BEST_WITH_VOLUME));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_TWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_TWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_TWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_TWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_AVERAGE_DURATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_AVERAGE_DURATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_AVERAGE_DURATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_AVERAGE_DURATION));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_AVERAGE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_AVERAGE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_AVERAGE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_AVERAGE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_TOTAL_FEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_TOTAL_FEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_TOTAL_FEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_TOTAL_FEES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_TOTAL_BENEFITS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_TOTAL_BENEFITS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_TOTAL_BENEFITS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_TOTAL_BENEFITS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_MEDIAN_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_MEDIAN_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_MEDIAN_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_MEDIAN_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_AVERAGE_LIQUIDITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_AVERAGE_LIQUIDITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_AVERAGE_LIQUIDITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_AVERAGE_LIQUIDITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticType_MEDIAN_DURATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticType_MEDIAN_DURATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticType_MEDIAN_DURATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticType_MEDIAN_DURATION));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_BID_PRICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_BID_PRICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_BID_PRICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_BID_PRICES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_OFFER_PRICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_OFFER_PRICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_OFFER_PRICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_OFFER_PRICES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_BID_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_BID_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_BID_DEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_BID_DEPTH));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_OFFER_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_OFFER_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_OFFER_DEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_OFFER_DEPTH));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_QUOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_QUOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_QUOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_QUOTES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_ORDERS_AND_QUOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_ORDERS_AND_QUOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_ORDERS_AND_QUOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_ORDERS_AND_QUOTES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_TRADE_PRICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_TRADE_PRICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_TRADE_PRICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_TRADE_PRICES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_AUCTION_PRICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_AUCTION_PRICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_AUCTION_PRICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_AUCTION_PRICES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_OPENING_PRICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_OPENING_PRICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_OPENING_PRICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_OPENING_PRICES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_CLOSING_PRICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_CLOSING_PRICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_CLOSING_PRICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_CLOSING_PRICES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_SETTLEMENT_PRICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_SETTLEMENT_PRICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_SETTLEMENT_PRICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_SETTLEMENT_PRICES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_UNDERLYING_PRICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_UNDERLYING_PRICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_UNDERLYING_PRICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_UNDERLYING_PRICES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_OPEN_INTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_OPEN_INTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_OPEN_INTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_OPEN_INTEREST));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_INDEX_VALUES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_INDEX_VALUES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_INDEX_VALUES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_INDEX_VALUES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_MARGIN_RATES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_MARGIN_RATES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_MARGIN_RATES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_MARGIN_RATES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_OUTAGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_OUTAGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_OUTAGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_OUTAGES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_SCHEDULED_AUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_SCHEDULED_AUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_SCHEDULED_AUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_SCHEDULED_AUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_REFERENCE_PRICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_REFERENCE_PRICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_REFERENCE_PRICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_REFERENCE_PRICES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_TRADE_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_TRADE_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_TRADE_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_TRADE_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_MARKET_DATA_FEE_ITEMS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_MARKET_DATA_FEE_ITEMS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_MARKET_DATA_FEE_ITEMS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_MARKET_DATA_FEE_ITEMS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_REBATES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_REBATES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_REBATES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_REBATES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_DISCOUNTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_DISCOUNTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_DISCOUNTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_DISCOUNTS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_PAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_PAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_PAYMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_PAYMENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_TAXES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_TAXES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_TAXES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_TAXES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_LEVIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_LEVIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_LEVIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_LEVIES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_BENEFITS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_BENEFITS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_BENEFITS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_BENEFITS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_FEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_FEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_FEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_FEES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_ORDERS_RF_QS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_ORDERS_RF_QS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_ORDERS_RF_QS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_ORDERS_RF_QS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_MARKET_MAKERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_MARKET_MAKERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_MARKET_MAKERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_MARKET_MAKERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_TRADING_INTERRUPTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_TRADING_INTERRUPTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_TRADING_INTERRUPTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_TRADING_INTERRUPTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_TRADING_SUSPENSIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_TRADING_SUSPENSIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_TRADING_SUSPENSIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_TRADING_SUSPENSIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_NO_QUOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_NO_QUOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_NO_QUOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_NO_QUOTES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_REQUEST_FOR_QUOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_REQUEST_FOR_QUOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_REQUEST_FOR_QUOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_REQUEST_FOR_QUOTES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScope_TRADE_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScope_TRADE_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScope_TRADE_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScope_TRADE_VOLUME));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_VISIBLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_VISIBLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_VISIBLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_VISIBLE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_HIDDEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_HIDDEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_HIDDEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_HIDDEN));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_INDICATIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_INDICATIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_INDICATIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_INDICATIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_TRADEABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_PASSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_PASSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_PASSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_PASSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_MARKET_CONSENSUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_MARKET_CONSENSUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_MARKET_CONSENSUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_MARKET_CONSENSUS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_POWER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_POWER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_POWER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_POWER));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_HARDWARE_ERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_HARDWARE_ERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_HARDWARE_ERROR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_HARDWARE_ERROR));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_SOFTWARE_ERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_SOFTWARE_ERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_SOFTWARE_ERROR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_SOFTWARE_ERROR));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_NETWORK_ERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_NETWORK_ERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_NETWORK_ERROR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_NETWORK_ERROR));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_FAILED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_FAILED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_FAILED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_FAILED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_EXECUTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_EXECUTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_EXECUTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_EXECUTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_ENTERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_ENTERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_ENTERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_ENTERED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_MODIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_MODIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_MODIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_MODIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_CANCELLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_CANCELLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_CANCELLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_CANCELLED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_MARKET_DATA_ACCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_MARKET_DATA_ACCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_MARKET_DATA_ACCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_MARKET_DATA_ACCESS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_TERMINAL_ACCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_TERMINAL_ACCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_TERMINAL_ACCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_TERMINAL_ACCESS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_VOLUME));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_CLEARED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_CLEARED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_CLEARED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_CLEARED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_SETTLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_SETTLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_SETTLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_SETTLED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_MONETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_MONETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_MONETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_MONETARY));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_NON_MONETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_NON_MONETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_NON_MONETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_NON_MONETARY));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_GROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_GROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_GROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_GROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_LARGE_IN_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_LARGE_IN_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_LARGE_IN_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_LARGE_IN_SCALE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_NEITHER_HIDDEN_NOR_LARGE_IN_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_NEITHER_HIDDEN_NOR_LARGE_IN_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_NEITHER_HIDDEN_NOR_LARGE_IN_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_NEITHER_HIDDEN_NOR_LARGE_IN_SCALE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_CORPORATE_ACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_CORPORATE_ACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_CORPORATE_ACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_CORPORATE_ACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_VENUE_DECISION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_VENUE_DECISION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_VENUE_DECISION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_VENUE_DECISION));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_MINIMUM_TIME_PERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_MINIMUM_TIME_PERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_MINIMUM_TIME_PERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_MINIMUM_TIME_PERIOD));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_NOT_EXECUTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_NOT_EXECUTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_NOT_EXECUTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_NOT_EXECUTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_AGGRESSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_AGGRESSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_AGGRESSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_AGGRESSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticSubScope_DIRECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticSubScope_DIRECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticSubScope_DIRECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticSubScope_DIRECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScopeType_ENTRY_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScopeType_ENTRY_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScopeType_ENTRY_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScopeType_ENTRY_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScopeType_MODIFICATION_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScopeType_MODIFICATION_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScopeType_MODIFICATION_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScopeType_MODIFICATION_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScopeType_CANCEL_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScopeType_CANCEL_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScopeType_CANCEL_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScopeType_CANCEL_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScopeType_DOWNWARD_MOVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScopeType_DOWNWARD_MOVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScopeType_DOWNWARD_MOVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScopeType_DOWNWARD_MOVE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticScopeType_UPWARD_MOVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticScopeType_UPWARD_MOVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticScopeType_UPWARD_MOVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticScopeType_UPWARD_MOVE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticIntervalType_SLIDING_WINDOW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticIntervalType_SLIDING_WINDOW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticIntervalType_SLIDING_WINDOW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticIntervalType_SLIDING_WINDOW));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticIntervalType_SLIDING_WINDOW_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticIntervalType_SLIDING_WINDOW_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticIntervalType_SLIDING_WINDOW_PEAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticIntervalType_SLIDING_WINDOW_PEAK));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticIntervalType_FIXED_DATE_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticIntervalType_FIXED_DATE_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticIntervalType_FIXED_DATE_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticIntervalType_FIXED_DATE_RANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticIntervalType_FIXED_TIME_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticIntervalType_FIXED_TIME_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticIntervalType_FIXED_TIME_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticIntervalType_FIXED_TIME_RANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticIntervalType_CURRENT_TIME_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticIntervalType_CURRENT_TIME_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticIntervalType_CURRENT_TIME_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticIntervalType_CURRENT_TIME_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticIntervalType_PREVIOUS_TIME_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticIntervalType_PREVIOUS_TIME_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticIntervalType_PREVIOUS_TIME_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticIntervalType_PREVIOUS_TIME_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticIntervalType_MAXIMUM_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticIntervalType_MAXIMUM_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticIntervalType_MAXIMUM_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticIntervalType_MAXIMUM_RANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticIntervalType_MAXIMUM_RANGE_UP_TO_PREVIOUS_TIME_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticIntervalType_MAXIMUM_RANGE_UP_TO_PREVIOUS_TIME_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticIntervalType_MAXIMUM_RANGE_UP_TO_PREVIOUS_TIME_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticIntervalType_MAXIMUM_RANGE_UP_TO_PREVIOUS_TIME_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRatioType_BUYERS_TO_SELLERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRatioType_BUYERS_TO_SELLERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRatioType_BUYERS_TO_SELLERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRatioType_BUYERS_TO_SELLERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRatioType_UPTICKS_TO_DOWNTICKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRatioType_UPTICKS_TO_DOWNTICKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRatioType_UPTICKS_TO_DOWNTICKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRatioType_UPTICKS_TO_DOWNTICKS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRatioType_MARKET_MAKER_TO_NON_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRatioType_MARKET_MAKER_TO_NON_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRatioType_MARKET_MAKER_TO_NON_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRatioType_MARKET_MAKER_TO_NON_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRatioType_AUTOMATED_TO_NON_AUTOMATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRatioType_AUTOMATED_TO_NON_AUTOMATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRatioType_AUTOMATED_TO_NON_AUTOMATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRatioType_AUTOMATED_TO_NON_AUTOMATED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRatioType_ORDERS_TO_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRatioType_ORDERS_TO_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRatioType_ORDERS_TO_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRatioType_ORDERS_TO_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRatioType_QUOTES_TO_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRatioType_QUOTES_TO_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRatioType_QUOTES_TO_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRatioType_QUOTES_TO_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRatioType_ORDERS_AND_QUOTES_TO_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRatioType_ORDERS_AND_QUOTES_TO_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRatioType_ORDERS_AND_QUOTES_TO_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRatioType_ORDERS_AND_QUOTES_TO_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRatioType_FAILED_TO_TOTAL_TRADED_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRatioType_FAILED_TO_TOTAL_TRADED_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRatioType_FAILED_TO_TOTAL_TRADED_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRatioType_FAILED_TO_TOTAL_TRADED_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRatioType_BENEFITS_TO_TOTAL_TRADED_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRatioType_BENEFITS_TO_TOTAL_TRADED_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRatioType_BENEFITS_TO_TOTAL_TRADED_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRatioType_BENEFITS_TO_TOTAL_TRADED_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRatioType_FEES_TO_TOTAL_TRADED_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRatioType_FEES_TO_TOTAL_TRADED_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRatioType_FEES_TO_TOTAL_TRADED_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRatioType_FEES_TO_TOTAL_TRADED_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRatioType_TRADE_VOLUME_TO_TOTAL_TRADED_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRatioType_TRADE_VOLUME_TO_TOTAL_TRADED_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRatioType_TRADE_VOLUME_TO_TOTAL_TRADED_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRatioType_TRADE_VOLUME_TO_TOTAL_TRADED_VOLUME));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRatioType_ORDERS_TO_TOTAL_NUMBER_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRatioType_ORDERS_TO_TOTAL_NUMBER_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRatioType_ORDERS_TO_TOTAL_NUMBER_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRatioType_ORDERS_TO_TOTAL_NUMBER_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_INVALID_OR_UNKNOWN_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_INVALID_OR_UNKNOWN_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_MARKET_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_INVALID_OR_UNKNOWN_MARKET_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_MARKET_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_INVALID_OR_UNKNOWN_MARKET_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_SECURITY_LIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_INVALID_OR_UNKNOWN_SECURITY_LIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_SECURITY_LIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_INVALID_OR_UNKNOWN_SECURITY_LIST));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_INSTRUMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_INVALID_OR_UNKNOWN_INSTRUMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_INSTRUMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_INVALID_OR_UNKNOWN_INSTRUMENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_INVALID_PARTIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_INVALID_PARTIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_INVALID_PARTIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_INVALID_PARTIES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_TRADE_DATE_OUT_OF_SUPPORTED_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_TRADE_DATE_OUT_OF_SUPPORTED_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_TRADE_DATE_OUT_OF_SUPPORTED_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_TRADE_DATE_OUT_OF_SUPPORTED_RANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_UNSUPPORTED_STATISTIC_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_UNSUPPORTED_STATISTIC_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_UNSUPPORTED_SCOPE_OR_SUB_SCOPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_UNSUPPORTED_SCOPE_OR_SUB_SCOPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_UNSUPPORTED_SCOPE_OR_SUB_SCOPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_UNSUPPORTED_SCOPE_OR_SUB_SCOPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_UNSUPPORTED_SCOPE_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_UNSUPPORTED_SCOPE_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_UNSUPPORTED_SCOPE_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_UNSUPPORTED_SCOPE_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_MARKET_DEPTH_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_MARKET_DEPTH_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_MARKET_DEPTH_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_MARKET_DEPTH_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_FREQUENCY_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_FREQUENCY_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_FREQUENCY_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_FREQUENCY_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_INTERVAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_UNSUPPORTED_STATISTIC_INTERVAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_INTERVAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_UNSUPPORTED_STATISTIC_INTERVAL));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_DATE_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_UNSUPPORTED_STATISTIC_DATE_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_DATE_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_UNSUPPORTED_STATISTIC_DATE_RANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_TIME_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_UNSUPPORTED_STATISTIC_TIME_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_TIME_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_UNSUPPORTED_STATISTIC_TIME_RANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_UNSUPPORTED_RATIO_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_UNSUPPORTED_RATIO_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_UNSUPPORTED_RATIO_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_UNSUPPORTED_RATIO_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_TRADE_INPUT_SOURCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_INVALID_OR_UNKNOWN_TRADE_INPUT_SOURCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_TRADE_INPUT_SOURCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_INVALID_OR_UNKNOWN_TRADE_INPUT_SOURCE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_INVALID_OR_UNKNOWN_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_INVALID_OR_UNKNOWN_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_UNAUTHORIZED_FOR_STATISTIC_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_UNAUTHORIZED_FOR_STATISTIC_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_UNAUTHORIZED_FOR_STATISTIC_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_UNAUTHORIZED_FOR_STATISTIC_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticRequestResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticRequestResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticRequestResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticRequestResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticStatus_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticStatus_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticStatus_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticStatus_ACTIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticStatus_INACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticStatus_INACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticStatus_INACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticStatus_INACTIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticValueType_ABSOLUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticValueType_ABSOLUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticValueType_ABSOLUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticValueType_ABSOLUTE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDStatisticValueType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDStatisticValueType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDStatisticValueType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDStatisticValueType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetGroup_FINANCIALS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetGroup_FINANCIALS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetGroup_FINANCIALS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetGroup_FINANCIALS));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetGroup_COMMODITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetGroup_COMMODITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetGroup_COMMODITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetGroup_COMMODITIES));
  return pyobj;
}


SWIGINTERN int Swig_var_AssetGroup_ALTERNATIVE_INVESTMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssetGroup_ALTERNATIVE_INVESTMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssetGroup_ALTERNATIVE_INVESTMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AssetGroup_ALTERNATIVE_INVESTMENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_CollRptRejectReason_UNKNOWN_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollRptRejectReason_UNKNOWN_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollRptRejectReason_UNKNOWN_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollRptRejectReason_UNKNOWN_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollRptRejectReason_UNKNOWN_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollRptRejectReason_UNKNOWN_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollRptRejectReason_UNKNOWN_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollRptRejectReason_UNKNOWN_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollRptRejectReason_UNKNOWN_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollRptRejectReason_UNKNOWN_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollRptRejectReason_UNKNOWN_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollRptRejectReason_UNKNOWN_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_CollRptRejectReason_UNKNOWN_POSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollRptRejectReason_UNKNOWN_POSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollRptRejectReason_UNKNOWN_POSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollRptRejectReason_UNKNOWN_POSITION));
  return pyobj;
}


SWIGINTERN int Swig_var_CollRptRejectReason_UNACCEPTABLE_COLLATERAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollRptRejectReason_UNACCEPTABLE_COLLATERAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollRptRejectReason_UNACCEPTABLE_COLLATERAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollRptRejectReason_UNACCEPTABLE_COLLATERAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollRptRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollRptRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollRptRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollRptRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_CollRptStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollRptStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollRptStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollRptStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollRptStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollRptStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollRptStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollRptStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollRptStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollRptStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollRptStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollRptStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueType_ASW_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueType_ASW_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueType_ASW_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueType_ASW_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueType_OIS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueType_OIS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueType_OIS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueType_OIS));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueType_Z_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueType_Z_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueType_Z_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueType_Z_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueType_DISCOUNT_MARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueType_DISCOUNT_MARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueType_DISCOUNT_MARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueType_DISCOUNT_MARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueType_I_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueType_I_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueType_I_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueType_I_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueType_OAS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueType_OAS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueType_OAS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueType_OAS));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueType_G_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueType_G_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueType_G_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueType_G_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueType_CDS_BASIS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueType_CDS_BASIS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueType_CDS_BASIS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueType_CDS_BASIS));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueType_CDS_INTERPOLATED_BASIS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueType_CDS_INTERPOLATED_BASIS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueType_CDS_INTERPOLATED_BASIS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueType_CDS_INTERPOLATED_BASIS));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueType_DV01_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueType_DV01 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueType_DV01_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueType_DV01));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueType_PV01_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueType_PV01 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueType_PV01_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueType_PV01));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueType_CS01_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueType_CS01 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueType_CS01_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueType_CS01));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueSide_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueSide_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueSide_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueSide_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueSide_MID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueSide_MID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueSide_MID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueSide_MID));
  return pyobj;
}


SWIGINTERN int Swig_var_RelativeValueSide_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelativeValueSide_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelativeValueSide_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelativeValueSide_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReportEvent_START_INSTRUMENT_REF_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReportEvent_START_INSTRUMENT_REF_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReportEvent_START_INSTRUMENT_REF_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDReportEvent_START_INSTRUMENT_REF_DATA));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReportEvent_END_INSTRUMENT_REF_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReportEvent_END_INSTRUMENT_REF_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReportEvent_END_INSTRUMENT_REF_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDReportEvent_END_INSTRUMENT_REF_DATA));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReportEvent_START_OFF_MARKET_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReportEvent_START_OFF_MARKET_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReportEvent_START_OFF_MARKET_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDReportEvent_START_OFF_MARKET_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReportEvent_END_OFF_MARKET_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReportEvent_END_OFF_MARKET_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReportEvent_END_OFF_MARKET_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDReportEvent_END_OFF_MARKET_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReportEvent_START_ORDER_BOOK_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReportEvent_START_ORDER_BOOK_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReportEvent_START_ORDER_BOOK_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDReportEvent_START_ORDER_BOOK_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReportEvent_END_ORDER_BOOK_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReportEvent_END_ORDER_BOOK_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReportEvent_END_ORDER_BOOK_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDReportEvent_END_ORDER_BOOK_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReportEvent_START_OPEN_INTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReportEvent_START_OPEN_INTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReportEvent_START_OPEN_INTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDReportEvent_START_OPEN_INTEREST));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReportEvent_END_OPEN_INTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReportEvent_END_OPEN_INTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReportEvent_END_OPEN_INTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDReportEvent_END_OPEN_INTEREST));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReportEvent_START_SETTLEMENT_PRICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReportEvent_START_SETTLEMENT_PRICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReportEvent_START_SETTLEMENT_PRICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDReportEvent_START_SETTLEMENT_PRICES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReportEvent_END_SETTLEMENT_PRICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReportEvent_END_SETTLEMENT_PRICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReportEvent_END_SETTLEMENT_PRICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDReportEvent_END_SETTLEMENT_PRICES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReportEvent_START_STATS_REF_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReportEvent_START_STATS_REF_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReportEvent_START_STATS_REF_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDReportEvent_START_STATS_REF_DATA));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReportEvent_END_STATS_REF_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReportEvent_END_STATS_REF_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReportEvent_END_STATS_REF_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDReportEvent_END_STATS_REF_DATA));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReportEvent_START_STATISTICS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReportEvent_START_STATISTICS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReportEvent_START_STATISTICS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDReportEvent_START_STATISTICS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReportEvent_END_STATISTICS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReportEvent_END_STATISTICS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReportEvent_END_STATISTICS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDReportEvent_END_STATISTICS));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketSegmentStatus_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketSegmentStatus_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketSegmentStatus_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketSegmentStatus_ACTIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketSegmentStatus_INACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketSegmentStatus_INACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketSegmentStatus_INACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketSegmentStatus_INACTIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketSegmentStatus_PUBLISHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketSegmentStatus_PUBLISHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketSegmentStatus_PUBLISHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketSegmentStatus_PUBLISHED));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketSegmentType_POOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketSegmentType_POOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketSegmentType_POOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketSegmentType_POOL));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketSegmentType_RETAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketSegmentType_RETAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketSegmentType_RETAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketSegmentType_RETAIL));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketSegmentType_WHOLESALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketSegmentType_WHOLESALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketSegmentType_WHOLESALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketSegmentType_WHOLESALE));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketSegmentSubType_INTER_PRODUCT_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketSegmentSubType_INTER_PRODUCT_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketSegmentSubType_INTER_PRODUCT_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketSegmentSubType_INTER_PRODUCT_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketSegmentRelationship_MARKET_SEGMENT_POOL_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketSegmentRelationship_MARKET_SEGMENT_POOL_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketSegmentRelationship_MARKET_SEGMENT_POOL_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketSegmentRelationship_MARKET_SEGMENT_POOL_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketSegmentRelationship_RETAIL_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketSegmentRelationship_RETAIL_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketSegmentRelationship_RETAIL_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketSegmentRelationship_RETAIL_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketSegmentRelationship_WHOLESALE_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketSegmentRelationship_WHOLESALE_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketSegmentRelationship_WHOLESALE_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketSegmentRelationship_WHOLESALE_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteSideIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteSideIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteSideIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::QuoteSideIndicator_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteSideIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteSideIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteSideIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::QuoteSideIndicator_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_CustomerPriority_NO_PRIORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustomerPriority_NO_PRIORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustomerPriority_NO_PRIORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustomerPriority_NO_PRIORITY));
  return pyobj;
}


SWIGINTERN int Swig_var_CustomerPriority_UNCONDITIONAL_PRIORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustomerPriority_UNCONDITIONAL_PRIORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustomerPriority_UNCONDITIONAL_PRIORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustomerPriority_UNCONDITIONAL_PRIORITY));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSubMethod_SHARES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSubMethod_SHARES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSubMethod_SHARES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlSubMethod_SHARES));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSubMethod_DERIVATIVES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSubMethod_DERIVATIVES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSubMethod_DERIVATIVES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlSubMethod_DERIVATIVES));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSubMethod_PAYMENT_VS_PAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSubMethod_PAYMENT_VS_PAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSubMethod_PAYMENT_VS_PAYMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlSubMethod_PAYMENT_VS_PAYMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSubMethod_NOTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSubMethod_NOTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSubMethod_NOTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlSubMethod_NOTIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSubMethod_CASCADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSubMethod_CASCADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSubMethod_CASCADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlSubMethod_CASCADE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSubMethod_REPURCHASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSubMethod_REPURCHASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSubMethod_REPURCHASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlSubMethod_REPURCHASE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSubMethod_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSubMethod_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSubMethod_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlSubMethod_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_CalculationMethod_AUTOMATIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CalculationMethod_AUTOMATIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CalculationMethod_AUTOMATIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CalculationMethod_AUTOMATIC));
  return pyobj;
}


SWIGINTERN int Swig_var_CalculationMethod_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CalculationMethod_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CalculationMethod_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CalculationMethod_MANUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollateralAmountType_MARKET_VALUATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollateralAmountType_MARKET_VALUATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollateralAmountType_MARKET_VALUATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollateralAmountType_MARKET_VALUATION));
  return pyobj;
}


SWIGINTERN int Swig_var_CollateralAmountType_PORTFOLIO_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollateralAmountType_PORTFOLIO_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollateralAmountType_PORTFOLIO_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollateralAmountType_PORTFOLIO_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollateralAmountType_VALUE_CONFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollateralAmountType_VALUE_CONFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollateralAmountType_VALUE_CONFIRMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollateralAmountType_VALUE_CONFIRMED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollateralAmountType_COLLATERAL_CREDIT_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollateralAmountType_COLLATERAL_CREDIT_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollateralAmountType_COLLATERAL_CREDIT_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollateralAmountType_COLLATERAL_CREDIT_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollateralAmountType_ADDITIONAL_COLLATERAL_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollateralAmountType_ADDITIONAL_COLLATERAL_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollateralAmountType_ADDITIONAL_COLLATERAL_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollateralAmountType_ADDITIONAL_COLLATERAL_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollateralAmountType_ESTIMATED_MARKET_VALUATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollateralAmountType_ESTIMATED_MARKET_VALUATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollateralAmountType_ESTIMATED_MARKET_VALUATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollateralAmountType_ESTIMATED_MARKET_VALUATION));
  return pyobj;
}


SWIGINTERN int Swig_var_CommissionAmountType_UNSPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommissionAmountType_UNSPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommissionAmountType_UNSPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommissionAmountType_UNSPECIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_CommissionAmountType_ACCEPTANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommissionAmountType_ACCEPTANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommissionAmountType_ACCEPTANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommissionAmountType_ACCEPTANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_CommissionAmountType_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommissionAmountType_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommissionAmountType_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommissionAmountType_BROKER));
  return pyobj;
}


SWIGINTERN int Swig_var_CommissionAmountType_CLEARING_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommissionAmountType_CLEARING_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommissionAmountType_CLEARING_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommissionAmountType_CLEARING_BROKER));
  return pyobj;
}


SWIGINTERN int Swig_var_CommissionAmountType_RETAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommissionAmountType_RETAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommissionAmountType_RETAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommissionAmountType_RETAIL));
  return pyobj;
}


SWIGINTERN int Swig_var_CommissionAmountType_SALES_COMMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommissionAmountType_SALES_COMMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommissionAmountType_SALES_COMMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommissionAmountType_SALES_COMMISSION));
  return pyobj;
}


SWIGINTERN int Swig_var_CommissionAmountType_LOCAL_COMMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommissionAmountType_LOCAL_COMMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommissionAmountType_LOCAL_COMMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommissionAmountType_LOCAL_COMMISSION));
  return pyobj;
}


SWIGINTERN int Swig_var_CommissionAmountType_RESEARCH_PAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommissionAmountType_RESEARCH_PAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommissionAmountType_RESEARCH_PAYMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommissionAmountType_RESEARCH_PAYMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CashSettlPriceDefault_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashSettlPriceDefault_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashSettlPriceDefault_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CashSettlPriceDefault_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_CashSettlPriceDefault_HEDGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashSettlPriceDefault_HEDGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashSettlPriceDefault_HEDGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CashSettlPriceDefault_HEDGE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPVFinalPriceElectionFallback_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPVFinalPriceElectionFallback_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPVFinalPriceElectionFallback_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPVFinalPriceElectionFallback_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPVFinalPriceElectionFallback_HEDGE_ELECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPVFinalPriceElectionFallback_HEDGE_ELECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPVFinalPriceElectionFallback_HEDGE_ELECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPVFinalPriceElectionFallback_HEDGE_ELECTION));
  return pyobj;
}


SWIGINTERN int Swig_var_DividendEntitlementEvent_EX_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DividendEntitlementEvent_EX_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DividendEntitlementEvent_EX_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DividendEntitlementEvent_EX_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_DividendEntitlementEvent_RECORD_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DividendEntitlementEvent_RECORD_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DividendEntitlementEvent_RECORD_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DividendEntitlementEvent_RECORD_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_DividendAmountType_RECORD_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DividendAmountType_RECORD_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DividendAmountType_RECORD_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DividendAmountType_RECORD_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_DividendAmountType_EX_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DividendAmountType_EX_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DividendAmountType_EX_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DividendAmountType_EX_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_DividendAmountType_PAID_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DividendAmountType_PAID_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DividendAmountType_PAID_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DividendAmountType_PAID_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_DividendAmountType_PER_MASTER_CONFIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DividendAmountType_PER_MASTER_CONFIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DividendAmountType_PER_MASTER_CONFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DividendAmountType_PER_MASTER_CONFIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_NonCashDividendTreatment_POTENTIAL_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NonCashDividendTreatment_POTENTIAL_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NonCashDividendTreatment_POTENTIAL_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NonCashDividendTreatment_POTENTIAL_ADJUSTMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_NonCashDividendTreatment_CASH_EQUIVALENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NonCashDividendTreatment_CASH_EQUIVALENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NonCashDividendTreatment_CASH_EQUIVALENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NonCashDividendTreatment_CASH_EQUIVALENT));
  return pyobj;
}


SWIGINTERN int Swig_var_DividendComposition_EQUITY_AMOUNT_RECEIVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DividendComposition_EQUITY_AMOUNT_RECEIVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DividendComposition_EQUITY_AMOUNT_RECEIVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DividendComposition_EQUITY_AMOUNT_RECEIVER));
  return pyobj;
}


SWIGINTERN int Swig_var_DividendComposition_CALCULATION_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DividendComposition_CALCULATION_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DividendComposition_CALCULATION_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DividendComposition_CALCULATION_AGENT));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikeIndexQuote_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikeIndexQuote_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikeIndexQuote_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikeIndexQuote_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikeIndexQuote_MID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikeIndexQuote_MID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikeIndexQuote_MID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikeIndexQuote_MID));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikeIndexQuote_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikeIndexQuote_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikeIndexQuote_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikeIndexQuote_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_ExtraordinaryEventAdjustmentMethod_CALCULATION_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExtraordinaryEventAdjustmentMethod_CALCULATION_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExtraordinaryEventAdjustmentMethod_CALCULATION_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExtraordinaryEventAdjustmentMethod_CALCULATION_AGENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExtraordinaryEventAdjustmentMethod_OPTIONS_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExtraordinaryEventAdjustmentMethod_OPTIONS_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExtraordinaryEventAdjustmentMethod_OPTIONS_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExtraordinaryEventAdjustmentMethod_OPTIONS_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInterpolationPeriod_INITIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInterpolationPeriod_INITIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInterpolationPeriod_INITIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamInterpolationPeriod_INITIAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInterpolationPeriod_INITIAL_AND_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInterpolationPeriod_INITIAL_AND_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInterpolationPeriod_INITIAL_AND_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamInterpolationPeriod_INITIAL_AND_FINAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInterpolationPeriod_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInterpolationPeriod_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInterpolationPeriod_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamInterpolationPeriod_FINAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamInterpolationPeriod_ANY_PERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamInterpolationPeriod_ANY_PERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamInterpolationPeriod_ANY_PERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamInterpolationPeriod_ANY_PERIOD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamLinkStrikePriceType_VOLATILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamLinkStrikePriceType_VOLATILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamLinkStrikePriceType_VOLATILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamLinkStrikePriceType_VOLATILITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamLinkStrikePriceType_VARIANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamLinkStrikePriceType_VARIANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamLinkStrikePriceType_VARIANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamLinkStrikePriceType_VARIANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRealizedVarianceMethod_PREVIOUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRealizedVarianceMethod_PREVIOUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRealizedVarianceMethod_PREVIOUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamRealizedVarianceMethod_PREVIOUS));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRealizedVarianceMethod_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRealizedVarianceMethod_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRealizedVarianceMethod_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamRealizedVarianceMethod_LAST));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentStreamRealizedVarianceMethod_BOTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentStreamRealizedVarianceMethod_BOTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentStreamRealizedVarianceMethod_BOTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentStreamRealizedVarianceMethod_BOTH));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionBreakFeeElection_FLAT_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionBreakFeeElection_FLAT_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionBreakFeeElection_FLAT_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionBreakFeeElection_FLAT_FEE));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionBreakFeeElection_AMORTIZED_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionBreakFeeElection_AMORTIZED_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionBreakFeeElection_AMORTIZED_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionBreakFeeElection_AMORTIZED_FEE));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionBreakFeeElection_FUNDING_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionBreakFeeElection_FUNDING_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionBreakFeeElection_FUNDING_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionBreakFeeElection_FUNDING_FEE));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionBreakFeeElection_FLAT_AND_FUNDING_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionBreakFeeElection_FLAT_AND_FUNDING_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionBreakFeeElection_FLAT_AND_FUNDING_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionBreakFeeElection_FLAT_AND_FUNDING_FEE));
  return pyobj;
}


SWIGINTERN int Swig_var_ProvisionBreakFeeElection_AMORTIZED_AND_FUNDING_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProvisionBreakFeeElection_AMORTIZED_AND_FUNDING_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProvisionBreakFeeElection_AMORTIZED_AND_FUNDING_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProvisionBreakFeeElection_AMORTIZED_AND_FUNDING_FEE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRateDateMode_PRICE_VALUATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRateDateMode_PRICE_VALUATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRateDateMode_PRICE_VALUATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRateDateMode_PRICE_VALUATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRateDateMode_DIVIDEND_VALUATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRateDateMode_DIVIDEND_VALUATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRateDateMode_DIVIDEND_VALUATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRateDateMode_DIVIDEND_VALUATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRatePriceSequence_INITIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRatePriceSequence_INITIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRatePriceSequence_INITIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRatePriceSequence_INITIAL));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRatePriceSequence_INTERIM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRatePriceSequence_INTERIM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRatePriceSequence_INTERIM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRatePriceSequence_INTERIM));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRatePriceSequence_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRatePriceSequence_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRatePriceSequence_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRatePriceSequence_FINAL));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRateQuoteTimeType_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRateQuoteTimeType_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRateQuoteTimeType_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRateQuoteTimeType_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRateQuoteTimeType_OFFICIAL_SETTL_PX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRateQuoteTimeType_OFFICIAL_SETTL_PX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRateQuoteTimeType_OFFICIAL_SETTL_PX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRateQuoteTimeType_OFFICIAL_SETTL_PX));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRateQuoteTimeType_XETRA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRateQuoteTimeType_XETRA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRateQuoteTimeType_XETRA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRateQuoteTimeType_XETRA));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRateQuoteTimeType_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRateQuoteTimeType_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRateQuoteTimeType_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRateQuoteTimeType_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRateQuoteTimeType_DERIVATIVES_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRateQuoteTimeType_DERIVATIVES_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRateQuoteTimeType_DERIVATIVES_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRateQuoteTimeType_DERIVATIVES_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRateQuoteTimeType_HIGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRateQuoteTimeType_HIGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRateQuoteTimeType_HIGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRateQuoteTimeType_HIGH));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRateQuoteTimeType_LOW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRateQuoteTimeType_LOW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRateQuoteTimeType_LOW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRateQuoteTimeType_LOW));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRateQuoteTimeType_AS_SPECIFIED_IN_MASTER_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRateQuoteTimeType_AS_SPECIFIED_IN_MASTER_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRateQuoteTimeType_AS_SPECIFIED_IN_MASTER_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRateQuoteTimeType_AS_SPECIFIED_IN_MASTER_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRateValuationPriceOption_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRateValuationPriceOption_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRateValuationPriceOption_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRateValuationPriceOption_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRateValuationPriceOption_FUTURES_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRateValuationPriceOption_FUTURES_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRateValuationPriceOption_FUTURES_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRateValuationPriceOption_FUTURES_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRateValuationPriceOption_OPTIONS_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRateValuationPriceOption_OPTIONS_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRateValuationPriceOption_OPTIONS_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRateValuationPriceOption_OPTIONS_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRatePriceBasis_GROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRatePriceBasis_GROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRatePriceBasis_GROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRatePriceBasis_GROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRatePriceBasis_NET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRatePriceBasis_NET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRatePriceBasis_NET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRatePriceBasis_NET));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRatePriceBasis_ACCRUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRatePriceBasis_ACCRUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRatePriceBasis_ACCRUED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRatePriceBasis_ACCRUED));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRatePriceBasis_CLEAN_NET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRatePriceBasis_CLEAN_NET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRatePriceBasis_CLEAN_NET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRatePriceBasis_CLEAN_NET));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRatePriceType_ABSOLUTE_TERMS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRatePriceType_ABSOLUTE_TERMS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRatePriceType_ABSOLUTE_TERMS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRatePriceType_ABSOLUTE_TERMS));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnRatePriceType_PERCENTAGE_OF_NOTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnRatePriceType_PERCENTAGE_OF_NOTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnRatePriceType_PERCENTAGE_OF_NOTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnRatePriceType_PERCENTAGE_OF_NOTIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamNotionalAdjustments_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamNotionalAdjustments_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamNotionalAdjustments_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamNotionalAdjustments_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamNotionalAdjustments_PORTFOLIO_REBALANCING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamNotionalAdjustments_PORTFOLIO_REBALANCING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamNotionalAdjustments_PORTFOLIO_REBALANCING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamNotionalAdjustments_PORTFOLIO_REBALANCING));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamNotionalAdjustments_STANDARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamNotionalAdjustments_STANDARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamNotionalAdjustments_STANDARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamNotionalAdjustments_STANDARD));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingNotionalAdjustments_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingNotionalAdjustments_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingNotionalAdjustments_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingNotionalAdjustments_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingNotionalAdjustments_PORTFOLIO_REBALANCING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingNotionalAdjustments_PORTFOLIO_REBALANCING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingNotionalAdjustments_PORTFOLIO_REBALANCING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingNotionalAdjustments_PORTFOLIO_REBALANCING));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingNotionalAdjustments_STANDARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingNotionalAdjustments_STANDARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingNotionalAdjustments_STANDARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingNotionalAdjustments_STANDARD));
  return pyobj;
}


SWIGINTERN int Swig_var_RemunerationIndicator_NO_REMUNERATION_PAID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RemunerationIndicator_NO_REMUNERATION_PAID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RemunerationIndicator_NO_REMUNERATION_PAID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RemunerationIndicator_NO_REMUNERATION_PAID));
  return pyobj;
}


SWIGINTERN int Swig_var_RemunerationIndicator_REMUNERATION_PAID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RemunerationIndicator_REMUNERATION_PAID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RemunerationIndicator_REMUNERATION_PAID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RemunerationIndicator_REMUNERATION_PAID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRiskLimitStatus_DISABLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRiskLimitStatus_DISABLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRiskLimitStatus_DISABLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRiskLimitStatus_DISABLED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRiskLimitStatus_ENABLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRiskLimitStatus_ENABLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRiskLimitStatus_ENABLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRiskLimitStatus_ENABLED));
  return pyobj;
}


SWIGINTERN int Swig_var_AlgorithmicTradeIndicator_NON_ALGORITHMIC_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AlgorithmicTradeIndicator_NON_ALGORITHMIC_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AlgorithmicTradeIndicator_NON_ALGORITHMIC_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AlgorithmicTradeIndicator_NON_ALGORITHMIC_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_AlgorithmicTradeIndicator_ALGORITHMIC_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AlgorithmicTradeIndicator_ALGORITHMIC_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AlgorithmicTradeIndicator_ALGORITHMIC_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AlgorithmicTradeIndicator_ALGORITHMIC_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationType_PRE_TRADE_TRANSPARENCY_WAIVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationType_PRE_TRADE_TRANSPARENCY_WAIVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationType_PRE_TRADE_TRANSPARENCY_WAIVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationType_PRE_TRADE_TRANSPARENCY_WAIVER));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationType_POST_TRADE_DEFERRAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationType_POST_TRADE_DEFERRAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationType_POST_TRADE_DEFERRAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationType_POST_TRADE_DEFERRAL));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationType_EXEMPT_FROM_PUBLICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationType_EXEMPT_FROM_PUBLICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationType_EXEMPT_FROM_PUBLICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationType_EXEMPT_FROM_PUBLICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationType_ORDER_LEVEL_PUBLICATION_TO_SUBSCRIBERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationType_ORDER_LEVEL_PUBLICATION_TO_SUBSCRIBERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationType_ORDER_LEVEL_PUBLICATION_TO_SUBSCRIBERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationType_ORDER_LEVEL_PUBLICATION_TO_SUBSCRIBERS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationType_PRICE_LEVEL_PUBLICATION_TO_SUBSCRIBERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationType_PRICE_LEVEL_PUBLICATION_TO_SUBSCRIBERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationType_PRICE_LEVEL_PUBLICATION_TO_SUBSCRIBERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationType_PRICE_LEVEL_PUBLICATION_TO_SUBSCRIBERS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationType_ORDER_LEVEL_PUBLICATION_TO_THE_PUBLIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationType_ORDER_LEVEL_PUBLICATION_TO_THE_PUBLIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationType_ORDER_LEVEL_PUBLICATION_TO_THE_PUBLIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationType_ORDER_LEVEL_PUBLICATION_TO_THE_PUBLIC));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationType_PUBLICATION_INTERNAL_TO_EXECUTION_VENUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationType_PUBLICATION_INTERNAL_TO_EXECUTION_VENUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationType_PUBLICATION_INTERNAL_TO_EXECUTION_VENUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationType_PUBLICATION_INTERNAL_TO_EXECUTION_VENUE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_AVERAGE_SPREAD_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_AVERAGE_SPREAD_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_AVERAGE_SPREAD_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_AVERAGE_SPREAD_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_REF_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_REF_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_REF_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_REF_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_OTHER_CONDITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_OTHER_CONDITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_OTHER_CONDITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_OTHER_CONDITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_REF_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_REF_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_REF_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_REF_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_ILLIQUID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_ILLIQUID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_ILLIQUID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_ILLIQUID));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_ORDER_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_ORDER_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_ORDER_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_ORDER_SIZE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_DEFERRAL_DUE_TO_LARGE_IN_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_DEFERRAL_DUE_TO_LARGE_IN_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_DEFERRAL_DUE_TO_LARGE_IN_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_DEFERRAL_DUE_TO_LARGE_IN_SCALE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_DEFERRAL_DUE_TO_ILLIQUID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_DEFERRAL_DUE_TO_ILLIQUID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_DEFERRAL_DUE_TO_ILLIQUID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_DEFERRAL_DUE_TO_ILLIQUID));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_DEFERRAL_DUE_TO_SIZE_SPECIFIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_DEFERRAL_DUE_TO_SIZE_SPECIFIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_DEFERRAL_DUE_TO_SIZE_SPECIFIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_DEFERRAL_DUE_TO_SIZE_SPECIFIC));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_LARGE_IN_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_LARGE_IN_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_LARGE_IN_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_LARGE_IN_SCALE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_SIZE_DUE_TO_ORDER_HIDDEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_NO_PUBLIC_PRICE_SIZE_DUE_TO_ORDER_HIDDEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_SIZE_DUE_TO_ORDER_HIDDEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_NO_PUBLIC_PRICE_SIZE_DUE_TO_ORDER_HIDDEN));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_EXEMPTED_DUE_TO_SECURITIES_FINANCING_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_EXEMPTED_DUE_TO_SECURITIES_FINANCING_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_EXEMPTED_DUE_TO_SECURITIES_FINANCING_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_EXEMPTED_DUE_TO_SECURITIES_FINANCING_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_EXEMPTED_DUE_TO_ESCB_POLICY_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_EXEMPTED_DUE_TO_ESCB_POLICY_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_EXEMPTED_DUE_TO_ESCB_POLICY_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_EXEMPTED_DUE_TO_ESCB_POLICY_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_EXCEPTION_DUE_TO_REPORT_BY_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_EXCEPTION_DUE_TO_REPORT_BY_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_EXCEPTION_DUE_TO_REPORT_BY_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_EXCEPTION_DUE_TO_REPORT_BY_PAPER));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_EXCEPTION_DUE_TO_TRADE_EXECUTED_WITH_NON_REPORTING_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_EXCEPTION_DUE_TO_TRADE_EXECUTED_WITH_NON_REPORTING_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_EXCEPTION_DUE_TO_TRADE_EXECUTED_WITH_NON_REPORTING_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_EXCEPTION_DUE_TO_TRADE_EXECUTED_WITH_NON_REPORTING_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_EXCEPTION_DUE_TO_INTRA_FIRM_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_EXCEPTION_DUE_TO_INTRA_FIRM_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_EXCEPTION_DUE_TO_INTRA_FIRM_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_EXCEPTION_DUE_TO_INTRA_FIRM_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegPublicationReason_REPORTED_OUTSIDE_REPORTING_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegPublicationReason_REPORTED_OUTSIDE_REPORTING_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegPublicationReason_REPORTED_OUTSIDE_REPORTING_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegPublicationReason_REPORTED_OUTSIDE_REPORTING_HOURS));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossedIndicator_NO_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossedIndicator_NO_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossedIndicator_NO_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossedIndicator_NO_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossedIndicator_CROSS_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossedIndicator_CROSS_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossedIndicator_CROSS_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossedIndicator_CROSS_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossedIndicator_CROSS_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossedIndicator_CROSS_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossedIndicator_CROSS_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossedIndicator_CROSS_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_AGGREGATED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_AGGREGATED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_AGGREGATED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_AGGREGATED_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_PENDING_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_PENDING_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_PENDING_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_PENDING_ALLOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_LIQUIDITY_PROVISION_ACTIVITY_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_LIQUIDITY_PROVISION_ACTIVITY_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_LIQUIDITY_PROVISION_ACTIVITY_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_LIQUIDITY_PROVISION_ACTIVITY_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_RISK_REDUCTION_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_RISK_REDUCTION_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_RISK_REDUCTION_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_RISK_REDUCTION_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_ALGORITHMIC_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_ALGORITHMIC_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_ALGORITHMIC_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_ALGORITHMIC_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_SYSTEMATIC_INTERNALISER_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_SYSTEMATIC_INTERNALISER_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_SYSTEMATIC_INTERNALISER_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_SYSTEMATIC_INTERNALISER_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_ALL_EXECUTIONS_SUBMITTED_TO_APA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_ALL_EXECUTIONS_SUBMITTED_TO_APA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_ALL_EXECUTIONS_SUBMITTED_TO_APA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_ALL_EXECUTIONS_SUBMITTED_TO_APA));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_ORDER_EXECUTION_INSTRUCTED_BY_CLIENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_ORDER_EXECUTION_INSTRUCTED_BY_CLIENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_ORDER_EXECUTION_INSTRUCTED_BY_CLIENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_ORDER_EXECUTION_INSTRUCTED_BY_CLIENT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_LARGE_IN_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_LARGE_IN_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_LARGE_IN_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_LARGE_IN_SCALE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_HIDDEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_HIDDEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_HIDDEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_HIDDEN));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_SUBJECT_TO_EUSTO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_SUBJECT_TO_EUSTO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_SUBJECT_TO_EUSTO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_SUBJECT_TO_EUSTO));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_SUBJECT_TO_UKSTO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_SUBJECT_TO_UKSTO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_SUBJECT_TO_UKSTO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_SUBJECT_TO_UKSTO));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_REPRESENTATIVE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_REPRESENTATIVE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_REPRESENTATIVE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_REPRESENTATIVE_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_LINKAGE_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_LINKAGE_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_LINKAGE_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_LINKAGE_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderAttributeType_EXEMPT_FROM_STO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderAttributeType_EXEMPT_FROM_STO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderAttributeType_EXEMPT_FROM_STO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderAttributeType_EXEMPT_FROM_STO));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportingIndicator_NOT_REPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportingIndicator_NOT_REPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportingIndicator_NOT_REPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportingIndicator_NOT_REPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportingIndicator_ON_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportingIndicator_ON_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportingIndicator_ON_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportingIndicator_ON_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportingIndicator_SI_SELLER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportingIndicator_SI_SELLER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportingIndicator_SI_SELLER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportingIndicator_SI_SELLER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportingIndicator_SI_BUYER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportingIndicator_SI_BUYER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportingIndicator_SI_BUYER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportingIndicator_SI_BUYER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportingIndicator_NON_SI_SELLER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportingIndicator_NON_SI_SELLER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportingIndicator_NON_SI_SELLER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportingIndicator_NON_SI_SELLER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportingIndicator_SUB_DELEGATION_BY_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportingIndicator_SUB_DELEGATION_BY_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportingIndicator_SUB_DELEGATION_BY_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportingIndicator_SUB_DELEGATION_BY_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportingIndicator_REPORTABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportingIndicator_REPORTABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportingIndicator_REPORTABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportingIndicator_REPORTABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportingIndicator_NON_SI_BUYER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportingIndicator_NON_SI_BUYER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportingIndicator_NON_SI_BUYER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportingIndicator_NON_SI_BUYER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportingIndicator_OFF_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportingIndicator_OFF_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportingIndicator_OFF_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportingIndicator_OFF_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportingIndicator_NOT_REPORTABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportingIndicator_NOT_REPORTABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportingIndicator_NOT_REPORTABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportingIndicator_NOT_REPORTABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionReason_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionReason_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionReason_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionReason_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionReason_TRADING_RISK_CONTROL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionReason_TRADING_RISK_CONTROL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionReason_TRADING_RISK_CONTROL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionReason_TRADING_RISK_CONTROL));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionReason_CLEARING_RISK_CONTROL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionReason_CLEARING_RISK_CONTROL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionReason_CLEARING_RISK_CONTROL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionReason_CLEARING_RISK_CONTROL));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionReason_MARKET_MAKER_PROTECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionReason_MARKET_MAKER_PROTECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionReason_MARKET_MAKER_PROTECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionReason_MARKET_MAKER_PROTECTION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionReason_STOP_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionReason_STOP_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionReason_STOP_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionReason_STOP_TRADING));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionReason_EMERGENCY_ACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionReason_EMERGENCY_ACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionReason_EMERGENCY_ACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionReason_EMERGENCY_ACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionReason_SESSION_LOSS_LOGOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionReason_SESSION_LOSS_LOGOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionReason_SESSION_LOSS_LOGOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionReason_SESSION_LOSS_LOGOUT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionReason_DUPLICATE_LOGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionReason_DUPLICATE_LOGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionReason_DUPLICATE_LOGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionReason_DUPLICATE_LOGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionReason_PRODUCT_NOT_TRADED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionReason_PRODUCT_NOT_TRADED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionReason_PRODUCT_NOT_TRADED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionReason_PRODUCT_NOT_TRADED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionReason_INSTRUMENT_NOT_TRADED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionReason_INSTRUMENT_NOT_TRADED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionReason_INSTRUMENT_NOT_TRADED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionReason_INSTRUMENT_NOT_TRADED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionReason_COMPLE_INSTRUMENT_DELETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionReason_COMPLE_INSTRUMENT_DELETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionReason_COMPLE_INSTRUMENT_DELETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionReason_COMPLE_INSTRUMENT_DELETED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionReason_CIRCUIT_BREAKER_ACTIVATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionReason_CIRCUIT_BREAKER_ACTIVATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionReason_CIRCUIT_BREAKER_ACTIVATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionReason_CIRCUIT_BREAKER_ACTIVATED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_NotAffectedReason_ORDER_SUSPENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NotAffectedReason_ORDER_SUSPENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NotAffectedReason_ORDER_SUSPENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NotAffectedReason_ORDER_SUSPENDED));
  return pyobj;
}


SWIGINTERN int Swig_var_NotAffectedReason_INSTRUMENT_SUSPENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NotAffectedReason_INSTRUMENT_SUSPENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NotAffectedReason_INSTRUMENT_SUSPENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NotAffectedReason_INSTRUMENT_SUSPENDED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderOwnershipIndicator_NO_CHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderOwnershipIndicator_NO_CHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderOwnershipIndicator_NO_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderOwnershipIndicator_NO_CHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderOwnershipIndicator_EXECUTING_PARTY_CHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderOwnershipIndicator_EXECUTING_PARTY_CHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderOwnershipIndicator_EXECUTING_PARTY_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderOwnershipIndicator_EXECUTING_PARTY_CHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderOwnershipIndicator_ENTERING_PARTY_CHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderOwnershipIndicator_ENTERING_PARTY_CHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderOwnershipIndicator_ENTERING_PARTY_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderOwnershipIndicator_ENTERING_PARTY_CHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderOwnershipIndicator_SPECIFIED_PARTY_CHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderOwnershipIndicator_SPECIFIED_PARTY_CHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderOwnershipIndicator_SPECIFIED_PARTY_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderOwnershipIndicator_SPECIFIED_PARTY_CHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_InTheMoneyCondition_STANDARD_ITM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InTheMoneyCondition_STANDARD_ITM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InTheMoneyCondition_STANDARD_ITM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InTheMoneyCondition_STANDARD_ITM));
  return pyobj;
}


SWIGINTERN int Swig_var_InTheMoneyCondition_ATMITM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InTheMoneyCondition_ATMITM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InTheMoneyCondition_ATMITM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InTheMoneyCondition_ATMITM));
  return pyobj;
}


SWIGINTERN int Swig_var_InTheMoneyCondition_ATM_CALL_ITM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InTheMoneyCondition_ATM_CALL_ITM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InTheMoneyCondition_ATM_CALL_ITM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InTheMoneyCondition_ATM_CALL_ITM));
  return pyobj;
}


SWIGINTERN int Swig_var_InTheMoneyCondition_ATM_PUT_ITM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InTheMoneyCondition_ATM_PUT_ITM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InTheMoneyCondition_ATM_PUT_ITM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InTheMoneyCondition_ATM_PUT_ITM));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestinationType_NO_RESTRICTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationType_NO_RESTRICTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestinationType_NO_RESTRICTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExDestinationType_NO_RESTRICTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestinationType_TRADED_ONLY_ON_TRADING_VENUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationType_TRADED_ONLY_ON_TRADING_VENUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestinationType_TRADED_ONLY_ON_TRADING_VENUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExDestinationType_TRADED_ONLY_ON_TRADING_VENUE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestinationType_TRADED_ONLY_ON_SI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationType_TRADED_ONLY_ON_SI is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestinationType_TRADED_ONLY_ON_SI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExDestinationType_TRADED_ONLY_ON_SI));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestinationType_TRADED_ON_TRADING_VENUE_OR_SI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationType_TRADED_ON_TRADING_VENUE_OR_SI is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestinationType_TRADED_ON_TRADING_VENUE_OR_SI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExDestinationType_TRADED_ON_TRADING_VENUE_OR_SI));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketCondition_NORMAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketCondition_NORMAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketCondition_NORMAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketCondition_NORMAL));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketCondition_STRESSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketCondition_STRESSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketCondition_STRESSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketCondition_STRESSED));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketCondition_EXCEPTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketCondition_EXCEPTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketCondition_EXCEPTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarketCondition_EXCEPTIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAttributeType_QUOTE_ABOVE_STANDARD_MARKET_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAttributeType_QUOTE_ABOVE_STANDARD_MARKET_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAttributeType_QUOTE_ABOVE_STANDARD_MARKET_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAttributeType_QUOTE_ABOVE_STANDARD_MARKET_SIZE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAttributeType_QUOTE_ABOVE_SPECIFIC_INSTRUMENT_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAttributeType_QUOTE_ABOVE_SPECIFIC_INSTRUMENT_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAttributeType_QUOTE_ABOVE_SPECIFIC_INSTRUMENT_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAttributeType_QUOTE_ABOVE_SPECIFIC_INSTRUMENT_SIZE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAttributeType_QUOTE_APPLICABLE_FOR_LIQUIDTY_PROVISION_ACTIVITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAttributeType_QUOTE_APPLICABLE_FOR_LIQUIDTY_PROVISION_ACTIVITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAttributeType_QUOTE_APPLICABLE_FOR_LIQUIDTY_PROVISION_ACTIVITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAttributeType_QUOTE_APPLICABLE_FOR_LIQUIDTY_PROVISION_ACTIVITY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAttributeType_QUOTE_ISSUER_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAttributeType_QUOTE_ISSUER_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAttributeType_QUOTE_ISSUER_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAttributeType_QUOTE_ISSUER_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAttributeType_BID_OR_ASK_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAttributeType_BID_OR_ASK_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAttributeType_BID_OR_ASK_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAttributeType_BID_OR_ASK_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceQualifier_ACCRUED_INTEREST_IS_FACTORED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQualifier_ACCRUED_INTEREST_IS_FACTORED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceQualifier_ACCRUED_INTEREST_IS_FACTORED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceQualifier_ACCRUED_INTEREST_IS_FACTORED));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceQualifier_TAX_IS_FACTORED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQualifier_TAX_IS_FACTORED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceQualifier_TAX_IS_FACTORED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceQualifier_TAX_IS_FACTORED));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceQualifier_BOND_AMORTIZATION_IS_FACTORED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQualifier_BOND_AMORTIZATION_IS_FACTORED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceQualifier_BOND_AMORTIZATION_IS_FACTORED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceQualifier_BOND_AMORTIZATION_IS_FACTORED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDValueTier_RANGE1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDValueTier_RANGE1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDValueTier_RANGE1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDValueTier_RANGE1));
  return pyobj;
}


SWIGINTERN int Swig_var_MDValueTier_RANGE2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDValueTier_RANGE2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDValueTier_RANGE2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDValueTier_RANGE2));
  return pyobj;
}


SWIGINTERN int Swig_var_MDValueTier_RANGE3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDValueTier_RANGE3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDValueTier_RANGE3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDValueTier_RANGE3));
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeQualifier_CONTRIBUTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeQualifier_CONTRIBUTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeQualifier_CONTRIBUTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MiscFeeQualifier_CONTRIBUTES));
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeQualifier_DOES_NOT_CONTRIBUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeQualifier_DOES_NOT_CONTRIBUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeQualifier_DOES_NOT_CONTRIBUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MiscFeeQualifier_DOES_NOT_CONTRIBUTE));
  return pyobj;
}


SWIGINTERN int Swig_var_CommissionAmountSubType_RESEARCH_PAYMENT_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommissionAmountSubType_RESEARCH_PAYMENT_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommissionAmountSubType_RESEARCH_PAYMENT_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommissionAmountSubType_RESEARCH_PAYMENT_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_CommissionAmountSubType_COMMISSION_SHARING_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommissionAmountSubType_COMMISSION_SHARING_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommissionAmountSubType_COMMISSION_SHARING_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommissionAmountSubType_COMMISSION_SHARING_AGREEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CommissionAmountSubType_OTHER_TYPE_RESEARCH_PAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommissionAmountSubType_OTHER_TYPE_RESEARCH_PAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommissionAmountSubType_OTHER_TYPE_RESEARCH_PAYMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommissionAmountSubType_OTHER_TYPE_RESEARCH_PAYMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CommodityFinalPriceType_ARGUS_MC_CLOSKEY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommodityFinalPriceType_ARGUS_MC_CLOSKEY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommodityFinalPriceType_ARGUS_MC_CLOSKEY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommodityFinalPriceType_ARGUS_MC_CLOSKEY));
  return pyobj;
}


SWIGINTERN int Swig_var_CommodityFinalPriceType_BALTIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommodityFinalPriceType_BALTIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommodityFinalPriceType_BALTIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommodityFinalPriceType_BALTIC));
  return pyobj;
}


SWIGINTERN int Swig_var_CommodityFinalPriceType_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommodityFinalPriceType_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommodityFinalPriceType_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommodityFinalPriceType_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_CommodityFinalPriceType_GLOBAL_COAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommodityFinalPriceType_GLOBAL_COAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommodityFinalPriceType_GLOBAL_COAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommodityFinalPriceType_GLOBAL_COAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CommodityFinalPriceType_IHS_MC_CLOSKEY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommodityFinalPriceType_IHS_MC_CLOSKEY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommodityFinalPriceType_IHS_MC_CLOSKEY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommodityFinalPriceType_IHS_MC_CLOSKEY));
  return pyobj;
}


SWIGINTERN int Swig_var_CommodityFinalPriceType_PLATTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommodityFinalPriceType_PLATTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommodityFinalPriceType_PLATTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommodityFinalPriceType_PLATTS));
  return pyobj;
}


SWIGINTERN int Swig_var_CommodityFinalPriceType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommodityFinalPriceType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommodityFinalPriceType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CommodityFinalPriceType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_ReferenceDataDateType_ADMIT_TO_TRADE_REQUEST_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReferenceDataDateType_ADMIT_TO_TRADE_REQUEST_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReferenceDataDateType_ADMIT_TO_TRADE_REQUEST_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReferenceDataDateType_ADMIT_TO_TRADE_REQUEST_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReferenceDataDateType_ADMIT_TO_TRADE_APPROVAL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReferenceDataDateType_ADMIT_TO_TRADE_APPROVAL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReferenceDataDateType_ADMIT_TO_TRADE_APPROVAL_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReferenceDataDateType_ADMIT_TO_TRADE_APPROVAL_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReferenceDataDateType_ADMIT_TO_TRADE_OR_FIRST_TRADE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReferenceDataDateType_ADMIT_TO_TRADE_OR_FIRST_TRADE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReferenceDataDateType_ADMIT_TO_TRADE_OR_FIRST_TRADE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReferenceDataDateType_ADMIT_TO_TRADE_OR_FIRST_TRADE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReferenceDataDateType_TERMINATION_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReferenceDataDateType_TERMINATION_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReferenceDataDateType_TERMINATION_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReferenceDataDateType_TERMINATION_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnTrigger_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnTrigger_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnTrigger_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnTrigger_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnTrigger_VARIANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnTrigger_VARIANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnTrigger_VARIANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnTrigger_VARIANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnTrigger_VOLATILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnTrigger_VOLATILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnTrigger_VOLATILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnTrigger_VOLATILITY));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnTrigger_TOTAL_RETURN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnTrigger_TOTAL_RETURN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnTrigger_TOTAL_RETURN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnTrigger_TOTAL_RETURN));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnTrigger_CONTRACT_FOR_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnTrigger_CONTRACT_FOR_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnTrigger_CONTRACT_FOR_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnTrigger_CONTRACT_FOR_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnTrigger_CREDIT_DEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnTrigger_CREDIT_DEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnTrigger_CREDIT_DEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnTrigger_CREDIT_DEFAULT));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnTrigger_SPREAD_BET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnTrigger_SPREAD_BET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnTrigger_SPREAD_BET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnTrigger_SPREAD_BET));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnTrigger_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnTrigger_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnTrigger_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnTrigger_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnTrigger_FORWARD_PRICE_UNDERLYING_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnTrigger_FORWARD_PRICE_UNDERLYING_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnTrigger_FORWARD_PRICE_UNDERLYING_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnTrigger_FORWARD_PRICE_UNDERLYING_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ReturnTrigger_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReturnTrigger_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReturnTrigger_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ReturnTrigger_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_AveragePriceType_TIME_WEIGHTED_AVERAGE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AveragePriceType_TIME_WEIGHTED_AVERAGE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AveragePriceType_TIME_WEIGHTED_AVERAGE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AveragePriceType_TIME_WEIGHTED_AVERAGE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_AveragePriceType_VOLUME_WEIGHTED_AVERAGE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AveragePriceType_VOLUME_WEIGHTED_AVERAGE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AveragePriceType_VOLUME_WEIGHTED_AVERAGE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AveragePriceType_VOLUME_WEIGHTED_AVERAGE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_AveragePriceType_PERCENT_OF_VOLUME_AVERAGE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AveragePriceType_PERCENT_OF_VOLUME_AVERAGE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AveragePriceType_PERCENT_OF_VOLUME_AVERAGE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AveragePriceType_PERCENT_OF_VOLUME_AVERAGE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_AveragePriceType_LIMIT_ORDER_AVERAGE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AveragePriceType_LIMIT_ORDER_AVERAGE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AveragePriceType_LIMIT_ORDER_AVERAGE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AveragePriceType_LIMIT_ORDER_AVERAGE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocGroupStatus_ADDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocGroupStatus_ADDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocGroupStatus_ADDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocGroupStatus_ADDED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocGroupStatus_CANCELED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocGroupStatus_CANCELED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocGroupStatus_CANCELED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocGroupStatus_CANCELED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocGroupStatus_REPLACED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocGroupStatus_REPLACED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocGroupStatus_REPLACED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocGroupStatus_REPLACED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocGroupStatus_CHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocGroupStatus_CHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocGroupStatus_CHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocGroupStatus_CHANGED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocGroupStatus_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocGroupStatus_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocGroupStatus_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocGroupStatus_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRequestStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRequestStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRequestStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRequestStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRequestStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRequestStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRequestStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRequestStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionType_NO_MATCHING_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionType_NO_MATCHING_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionType_NO_MATCHING_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionType_NO_MATCHING_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionType_NO_MATCHING_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionType_NO_MATCHING_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionType_NO_MATCHING_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionType_NO_MATCHING_ALLOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionType_ALLOCATION_DATA_ELEMENT_MISSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionType_ALLOCATION_DATA_ELEMENT_MISSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionType_ALLOCATION_DATA_ELEMENT_MISSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionType_ALLOCATION_DATA_ELEMENT_MISSING));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionType_CONFIRMATION_DATA_ELEMENT_MISSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionType_CONFIRMATION_DATA_ELEMENT_MISSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionType_CONFIRMATION_DATA_ELEMENT_MISSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionType_CONFIRMATION_DATA_ELEMENT_MISSING));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionType_DATA_DIFFERENCE_NOT_WITHIN_TOLERANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionType_DATA_DIFFERENCE_NOT_WITHIN_TOLERANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionType_DATA_DIFFERENCE_NOT_WITHIN_TOLERANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionType_DATA_DIFFERENCE_NOT_WITHIN_TOLERANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionType_MATCH_WITHIN_TOLERANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionType_MATCH_WITHIN_TOLERANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionType_MATCH_WITHIN_TOLERANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionType_MATCH_WITHIN_TOLERANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_ACCRUED_INTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_ACCRUED_INTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_ACCRUED_INTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_ACCRUED_INTEREST));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_DEAL_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_DEAL_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_DEAL_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_DEAL_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_TRADE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_TRADE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_TRADE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_TRADE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_SETTLEMENT_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_SETTLEMENT_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_SETTLEMENT_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_SETTLEMENT_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_SIDE_INDICATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_SIDE_INDICATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_SIDE_INDICATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_SIDE_INDICATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_TRADED_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_TRADED_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_TRADED_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_TRADED_CURRENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_ACCOUNT_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_ACCOUNT_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_ACCOUNT_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_ACCOUNT_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_EXECUTING_BROKER_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_EXECUTING_BROKER_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_EXECUTING_BROKER_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_EXECUTING_BROKER_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_SETTLEMENT_CURRENCY_AND_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_SETTLEMENT_CURRENCY_AND_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_SETTLEMENT_CURRENCY_AND_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_SETTLEMENT_CURRENCY_AND_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_INVESTMENT_MANAGER_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_INVESTMENT_MANAGER_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_INVESTMENT_MANAGER_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_INVESTMENT_MANAGER_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_NET_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_NET_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_NET_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_NET_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_PLACE_OF_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_PLACE_OF_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_PLACE_OF_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_PLACE_OF_SETTLEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_COMMISSIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_COMMISSIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_COMMISSIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_COMMISSIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_SECURITY_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_SECURITY_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_SECURITY_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_SECURITY_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_QUALITY_ALLOCATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_QUALITY_ALLOCATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_QUALITY_ALLOCATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_QUALITY_ALLOCATED));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_FEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_FEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_FEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_FEES));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionElementType_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionElementType_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionElementType_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionElementType_TAX));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionToleranceValueType_FIXED_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionToleranceValueType_FIXED_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionToleranceValueType_FIXED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionToleranceValueType_FIXED_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchExceptionToleranceValueType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchExceptionToleranceValueType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchExceptionToleranceValueType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchExceptionToleranceValueType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchingDataPointIndicator_MANDATORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchingDataPointIndicator_MANDATORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchingDataPointIndicator_MANDATORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchingDataPointIndicator_MANDATORY));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchingDataPointIndicator_OPTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchingDataPointIndicator_OPTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchingDataPointIndicator_OPTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MatchingDataPointIndicator_OPTIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAggregationTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAggregationTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAggregationTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAggregationTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAggregationTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAggregationTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAggregationTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAggregationTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAggregationTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAggregationTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAggregationTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAggregationTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAggregationRequestStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAggregationRequestStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAggregationRequestStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAggregationRequestStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAggregationRequestStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAggregationRequestStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAggregationRequestStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAggregationRequestStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAggregationRejectReason_UNKNOWN_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAggregationRejectReason_UNKNOWN_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAggregationRejectReason_UNKNOWN_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAggregationRejectReason_UNKNOWN_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAggregationRejectReason_UNKNOWN_EXECUTION_FILLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAggregationRejectReason_UNKNOWN_EXECUTION_FILLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAggregationRejectReason_UNKNOWN_EXECUTION_FILLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAggregationRejectReason_UNKNOWN_EXECUTION_FILLS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAggregationRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAggregationRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAggregationRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAggregationRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_OffshoreIndicator_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OffshoreIndicator_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OffshoreIndicator_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OffshoreIndicator_REGULAR));
  return pyobj;
}


SWIGINTERN int Swig_var_OffshoreIndicator_OFFSHORE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OffshoreIndicator_OFFSHORE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OffshoreIndicator_OFFSHORE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OffshoreIndicator_OFFSHORE));
  return pyobj;
}


SWIGINTERN int Swig_var_OffshoreIndicator_ONSHORE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OffshoreIndicator_ONSHORE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OffshoreIndicator_ONSHORE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OffshoreIndicator_ONSHORE));
  return pyobj;
}


SWIGINTERN int Swig_var_PayReportTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PayReportTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PayReportTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PayReportTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_PayReportTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PayReportTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PayReportTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PayReportTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_PayReportTransType_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PayReportTransType_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PayReportTransType_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PayReportTransType_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_PayReportStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PayReportStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PayReportStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PayReportStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_PayReportStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PayReportStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PayReportStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PayReportStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PayReportStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PayReportStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PayReportStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PayReportStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PayReportStatus_DISPUTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PayReportStatus_DISPUTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PayReportStatus_DISPUTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PayReportStatus_DISPUTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PayRequestTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PayRequestTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PayRequestTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PayRequestTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_PayRequestTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PayRequestTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PayRequestTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PayRequestTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_PayRequestStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PayRequestStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PayRequestStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PayRequestStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_PayRequestStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PayRequestStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PayRequestStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PayRequestStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PayRequestStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PayRequestStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PayRequestStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PayRequestStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PayRequestStatus_DISPUTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PayRequestStatus_DISPUTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PayRequestStatus_DISPUTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PayRequestStatus_DISPUTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PostTradePaymentDebitOrCredit_DEBIT_PAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostTradePaymentDebitOrCredit_DEBIT_PAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostTradePaymentDebitOrCredit_DEBIT_PAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PostTradePaymentDebitOrCredit_DEBIT_PAY));
  return pyobj;
}


SWIGINTERN int Swig_var_PostTradePaymentDebitOrCredit_CREDIT_RECEIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostTradePaymentDebitOrCredit_CREDIT_RECEIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostTradePaymentDebitOrCredit_CREDIT_RECEIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PostTradePaymentDebitOrCredit_CREDIT_RECEIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_PostTradePaymentStatus_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostTradePaymentStatus_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostTradePaymentStatus_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PostTradePaymentStatus_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_PostTradePaymentStatus_INITIATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostTradePaymentStatus_INITIATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostTradePaymentStatus_INITIATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PostTradePaymentStatus_INITIATED));
  return pyobj;
}


SWIGINTERN int Swig_var_PostTradePaymentStatus_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostTradePaymentStatus_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostTradePaymentStatus_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PostTradePaymentStatus_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_PostTradePaymentStatus_CONFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostTradePaymentStatus_CONFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostTradePaymentStatus_CONFIRMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PostTradePaymentStatus_CONFIRMED));
  return pyobj;
}


SWIGINTERN int Swig_var_PostTradePaymentStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostTradePaymentStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostTradePaymentStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PostTradePaymentStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_DuplicateClOrdIDIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DuplicateClOrdIDIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DuplicateClOrdIDIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DuplicateClOrdIDIndicator_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_DuplicateClOrdIDIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DuplicateClOrdIDIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DuplicateClOrdIDIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DuplicateClOrdIDIndicator_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_EventInitiatorType_CUSTOMER_OR_CLIENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventInitiatorType_CUSTOMER_OR_CLIENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventInitiatorType_CUSTOMER_OR_CLIENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::EventInitiatorType_CUSTOMER_OR_CLIENT));
  return pyobj;
}


SWIGINTERN int Swig_var_EventInitiatorType_EXCHANGE_OR_EXECUTION_VENUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventInitiatorType_EXCHANGE_OR_EXECUTION_VENUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventInitiatorType_EXCHANGE_OR_EXECUTION_VENUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::EventInitiatorType_EXCHANGE_OR_EXECUTION_VENUE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventInitiatorType_FIRM_OR_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventInitiatorType_FIRM_OR_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventInitiatorType_FIRM_OR_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::EventInitiatorType_FIRM_OR_BROKER));
  return pyobj;
}


SWIGINTERN int Swig_var_NBBOEntryType_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NBBOEntryType_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NBBOEntryType_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NBBOEntryType_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_NBBOEntryType_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NBBOEntryType_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NBBOEntryType_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NBBOEntryType_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_NBBOEntryType_MID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NBBOEntryType_MID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NBBOEntryType_MID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NBBOEntryType_MID_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_NBBOSource_NOT_APPLICABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NBBOSource_NOT_APPLICABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NBBOSource_NOT_APPLICABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NBBOSource_NOT_APPLICABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_NBBOSource_DIRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NBBOSource_DIRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NBBOSource_DIRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NBBOSource_DIRECT));
  return pyobj;
}


SWIGINTERN int Swig_var_NBBOSource_SIP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NBBOSource_SIP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NBBOSource_SIP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NBBOSource_SIP));
  return pyobj;
}


SWIGINTERN int Swig_var_NBBOSource_HYBRID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NBBOSource_HYBRID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NBBOSource_HYBRID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NBBOSource_HYBRID));
  return pyobj;
}


SWIGINTERN int Swig_var_SingleQuoteIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SingleQuoteIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SingleQuoteIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SingleQuoteIndicator_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_SingleQuoteIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SingleQuoteIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SingleQuoteIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SingleQuoteIndicator_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampManualIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampManualIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampManualIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TrdRegTimestampManualIndicator_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampManualIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampManualIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampManualIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TrdRegTimestampManualIndicator_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_CollateralReinvestmentType_MONEY_MARKET_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollateralReinvestmentType_MONEY_MARKET_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollateralReinvestmentType_MONEY_MARKET_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollateralReinvestmentType_MONEY_MARKET_FUND));
  return pyobj;
}


SWIGINTERN int Swig_var_CollateralReinvestmentType_OTHER_COMINGLED_POOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollateralReinvestmentType_OTHER_COMINGLED_POOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollateralReinvestmentType_OTHER_COMINGLED_POOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollateralReinvestmentType_OTHER_COMINGLED_POOL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollateralReinvestmentType_REPO_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollateralReinvestmentType_REPO_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollateralReinvestmentType_REPO_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollateralReinvestmentType_REPO_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_CollateralReinvestmentType_DIRECT_PURCHASE_OF_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollateralReinvestmentType_DIRECT_PURCHASE_OF_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollateralReinvestmentType_DIRECT_PURCHASE_OF_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollateralReinvestmentType_DIRECT_PURCHASE_OF_SECURITIES));
  return pyobj;
}


SWIGINTERN int Swig_var_CollateralReinvestmentType_OTHER_INVESTMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollateralReinvestmentType_OTHER_INVESTMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollateralReinvestmentType_OTHER_INVESTMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollateralReinvestmentType_OTHER_INVESTMENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_FundingSource_REPO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FundingSource_REPO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FundingSource_REPO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FundingSource_REPO));
  return pyobj;
}


SWIGINTERN int Swig_var_FundingSource_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FundingSource_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FundingSource_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FundingSource_CASH));
  return pyobj;
}


SWIGINTERN int Swig_var_FundingSource_FREE_CEDITS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FundingSource_FREE_CEDITS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FundingSource_FREE_CEDITS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FundingSource_FREE_CEDITS));
  return pyobj;
}


SWIGINTERN int Swig_var_FundingSource_CUSTOMER_SHORT_SALES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FundingSource_CUSTOMER_SHORT_SALES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FundingSource_CUSTOMER_SHORT_SALES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FundingSource_CUSTOMER_SHORT_SALES));
  return pyobj;
}


SWIGINTERN int Swig_var_FundingSource_BROKER_SHORT_SALES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FundingSource_BROKER_SHORT_SALES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FundingSource_BROKER_SHORT_SALES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FundingSource_BROKER_SHORT_SALES));
  return pyobj;
}


SWIGINTERN int Swig_var_FundingSource_UNSECURED_BORROWING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FundingSource_UNSECURED_BORROWING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FundingSource_UNSECURED_BORROWING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FundingSource_UNSECURED_BORROWING));
  return pyobj;
}


SWIGINTERN int Swig_var_FundingSource_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FundingSource_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FundingSource_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FundingSource_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginDirection_POSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginDirection_POSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginDirection_POSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginDirection_POSTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MarginDirection_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarginDirection_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarginDirection_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MarginDirection_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_TransactionAttributeType_EXCLUSIVE_ARRANGEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransactionAttributeType_EXCLUSIVE_ARRANGEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransactionAttributeType_EXCLUSIVE_ARRANGEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransactionAttributeType_EXCLUSIVE_ARRANGEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TransactionAttributeType_COLLATERAL_REUSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransactionAttributeType_COLLATERAL_REUSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransactionAttributeType_COLLATERAL_REUSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransactionAttributeType_COLLATERAL_REUSE));
  return pyobj;
}


SWIGINTERN int Swig_var_TransactionAttributeType_COLLATERAL_ARRANGMENT_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TransactionAttributeType_COLLATERAL_ARRANGMENT_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TransactionAttributeType_COLLATERAL_ARRANGMENT_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TransactionAttributeType_COLLATERAL_ARRANGMENT_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_RoutingArrangmentIndicator_NO_ROUTING_ARRANGMENT_IN_PLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoutingArrangmentIndicator_NO_ROUTING_ARRANGMENT_IN_PLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoutingArrangmentIndicator_NO_ROUTING_ARRANGMENT_IN_PLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingArrangmentIndicator_NO_ROUTING_ARRANGMENT_IN_PLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_RoutingArrangmentIndicator_ROUTING_ARRANGEMENT_IN_PLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoutingArrangmentIndicator_ROUTING_ARRANGEMENT_IN_PLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoutingArrangmentIndicator_ROUTING_ARRANGEMENT_IN_PLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingArrangmentIndicator_ROUTING_ARRANGEMENT_IN_PLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedOrderIDSource_NON_FIX_SOURCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedOrderIDSource_NON_FIX_SOURCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedOrderIDSource_NON_FIX_SOURCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedOrderIDSource_NON_FIX_SOURCE));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedOrderIDSource_SYSTEM_ORDER_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedOrderIDSource_SYSTEM_ORDER_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedOrderIDSource_SYSTEM_ORDER_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedOrderIDSource_SYSTEM_ORDER_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedOrderIDSource_CLIENT_ORDER_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedOrderIDSource_CLIENT_ORDER_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedOrderIDSource_CLIENT_ORDER_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedOrderIDSource_CLIENT_ORDER_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedOrderIDSource_SECONDARY_ORDER_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedOrderIDSource_SECONDARY_ORDER_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedOrderIDSource_SECONDARY_ORDER_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedOrderIDSource_SECONDARY_ORDER_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_RelatedOrderIDSource_SECONDARY_CLIENT_ORDER_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RelatedOrderIDSource_SECONDARY_CLIENT_ORDER_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RelatedOrderIDSource_SECONDARY_CLIENT_ORDER_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RelatedOrderIDSource_SECONDARY_CLIENT_ORDER_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRelationship_NOT_SPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRelationship_NOT_SPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRelationship_NOT_SPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderRelationship_NOT_SPECIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRelationship_ORDER_AGGREGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRelationship_ORDER_AGGREGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRelationship_ORDER_AGGREGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderRelationship_ORDER_AGGREGATION));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRelationship_ORDER_SPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRelationship_ORDER_SPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRelationship_ORDER_SPLIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderRelationship_ORDER_SPLIT));
  return pyobj;
}


SWIGINTERN int Swig_var_CurrencyCodeSource_CUSIP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CurrencyCodeSource_CUSIP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CurrencyCodeSource_CUSIP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CurrencyCodeSource_CUSIP);
  return pyobj;
}


SWIGINTERN int Swig_var_CurrencyCodeSource_SEDOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CurrencyCodeSource_SEDOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CurrencyCodeSource_SEDOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CurrencyCodeSource_SEDOL);
  return pyobj;
}


SWIGINTERN int Swig_var_CurrencyCodeSource_ISIN_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CurrencyCodeSource_ISIN_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CurrencyCodeSource_ISIN_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CurrencyCodeSource_ISIN_NUMBER);
  return pyobj;
}


SWIGINTERN int Swig_var_CurrencyCodeSource_ISO_CURRENCY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CurrencyCodeSource_ISO_CURRENCY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CurrencyCodeSource_ISO_CURRENCY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CurrencyCodeSource_ISO_CURRENCY_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_CurrencyCodeSource_FINANCIAL_INSTRUMENT_GLOBAL_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CurrencyCodeSource_FINANCIAL_INSTRUMENT_GLOBAL_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CurrencyCodeSource_FINANCIAL_INSTRUMENT_GLOBAL_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CurrencyCodeSource_FINANCIAL_INSTRUMENT_GLOBAL_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int Swig_var_CurrencyCodeSource_DIGITAL_TOKEN_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CurrencyCodeSource_DIGITAL_TOKEN_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CurrencyCodeSource_DIGITAL_TOKEN_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CurrencyCodeSource_DIGITAL_TOKEN_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int Swig_var_MultiJurisdictionReportingIndicator_NOT_MULTI_JRSDCTN_ELIGIBLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiJurisdictionReportingIndicator_NOT_MULTI_JRSDCTN_ELIGIBLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiJurisdictionReportingIndicator_NOT_MULTI_JRSDCTN_ELIGIBLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultiJurisdictionReportingIndicator_NOT_MULTI_JRSDCTN_ELIGIBLE));
  return pyobj;
}


SWIGINTERN int Swig_var_MultiJurisdictionReportingIndicator_MULTI_JRSDCTN_ELIGIBLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiJurisdictionReportingIndicator_MULTI_JRSDCTN_ELIGIBLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiJurisdictionReportingIndicator_MULTI_JRSDCTN_ELIGIBLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultiJurisdictionReportingIndicator_MULTI_JRSDCTN_ELIGIBLE));
  return pyobj;
}


SWIGINTERN int Swig_var_SelfMatchPreventionInstruction_CANCEL_AGGRESSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SelfMatchPreventionInstruction_CANCEL_AGGRESSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SelfMatchPreventionInstruction_CANCEL_AGGRESSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SelfMatchPreventionInstruction_CANCEL_AGGRESSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_SelfMatchPreventionInstruction_CANCEL_PASSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SelfMatchPreventionInstruction_CANCEL_PASSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SelfMatchPreventionInstruction_CANCEL_PASSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SelfMatchPreventionInstruction_CANCEL_PASSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_SelfMatchPreventionInstruction_CANCEL_AGGRESSIVE_PASSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SelfMatchPreventionInstruction_CANCEL_AGGRESSIVE_PASSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SelfMatchPreventionInstruction_CANCEL_AGGRESSIVE_PASSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SelfMatchPreventionInstruction_CANCEL_AGGRESSIVE_PASSIVE));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_SessionID__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::SessionID *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SessionID *)new FIX::SessionID();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionID__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  FIX::SessionID *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "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(swig_obj[2], &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_NullReferenceError, "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(swig_obj[3], &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_NullReferenceError, "invalid null reference " "in method '" "new_SessionID" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        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;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionID__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  FIX::SessionID *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "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(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "new_SessionID" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        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;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionID(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SessionID", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SessionID__SWIG_0(self, argc, argv);
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SessionID__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SessionID__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SessionID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SessionID::SessionID()\n"
    "    FIX::SessionID::SessionID(std::string const &,std::string const &,std::string const &,std::string const &)\n"
    "    FIX::SessionID::SessionID(std::string const &,std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SessionID_getBeginString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::BeginString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::BeginString *) &((FIX::SessionID const *)arg1)->getBeginString();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BeginString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_getSenderCompID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SenderCompID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SenderCompID *) &((FIX::SessionID const *)arg1)->getSenderCompID();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SenderCompID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_getTargetCompID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::TargetCompID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::TargetCompID *) &((FIX::SessionID const *)arg1)->getTargetCompID();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetCompID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_getSessionQualifier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::SessionID const *)arg1)->getSessionQualifier();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_isFIXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::SessionID const *)arg1)->isFIXT();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_toString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::SessionID const *)arg1)->toString();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_toStringFrozen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::SessionID const *)arg1)->toStringFrozen();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_fromString(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionID_fromString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "SessionID_fromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->fromString((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_toString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  std::string *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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*)PyUnicode_AsUTF8(swig_obj[1]));
    arg2 = &temp2;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::SessionID const *)arg1)->toString(*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_toString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SessionID_toString", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SessionID_toString__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SessionID_toString__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SessionID_toString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SessionID::toString() const\n"
    "    FIX::SessionID::toString(std::string &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_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_NullReferenceError, "invalid null reference " "in method '" "__lt__" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__lt__" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator <((FIX::SessionID const &)*arg1,(FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___eq____SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_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_NullReferenceError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator ==((FIX::SessionID const &)*arg1,(FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_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_NullReferenceError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator !=((FIX::SessionID const &)*arg1,(FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lshift____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::ostream *) &operator <<(*arg1,(FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___rshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::istream *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__rshift__" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__rshift__" "', argument " "2"" of type '" "FIX::SessionID &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::istream *) &operator >>(*arg1,*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__istream, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SessionID___invert__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SessionID result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::SessionID const *)arg1)->operator ~();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::SessionID(result)), SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX_SessionID___str__(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SessionID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SessionID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SessionID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SessionID_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Dictionary__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::Dictionary *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_Dictionary" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Dictionary *)new FIX::Dictionary((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dictionary__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::Dictionary *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Dictionary *)new FIX::Dictionary();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dictionary(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Dictionary", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Dictionary__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Dictionary__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Dictionary'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Dictionary::Dictionary(std::string const &)\n"
    "    FIX::Dictionary::Dictionary()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Dictionary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::Dictionary const *)arg1)->getName();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::Dictionary const *)arg1)->size();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Dictionary_getString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::Dictionary const *)arg1)->getString((std::string const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::string result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Dictionary_getString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::Dictionary const *)arg1)->getString((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Dictionary_getString", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Dictionary, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Dictionary_getString__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Dictionary, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Dictionary_getString__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Dictionary_getString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Dictionary::getString(std::string const &,bool) const\n"
    "    FIX::Dictionary::getString(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Dictionary_getInt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dictionary_getInt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getInt" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dictionary_getInt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Dictionary_getInt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::Dictionary const *)arg1)->getInt((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getDouble(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dictionary_getDouble", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Dictionary_getDouble" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (double)((FIX::Dictionary const *)arg1)->getDouble((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getBool(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dictionary_getBool", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Dictionary_getBool" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Dictionary const *)arg1)->getBool((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getDay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dictionary_getDay", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Dictionary_getDay" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)((FIX::Dictionary const *)arg1)->getDay((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_setString(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dictionary_setString", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "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(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "Dictionary_setString" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setString((std::string const &)*arg2,(std::string const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_setInt(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dictionary_setInt", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_setInt" "', argument " "1"" of type '" "FIX::Dictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dictionary_setInt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Dictionary_setInt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_setInt" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setInt((std::string const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_setDouble(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dictionary_setDouble", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Dictionary_setDouble" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setDouble((std::string const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_setBool(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dictionary_setBool", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Dictionary_setBool" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setBool((std::string const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_setDay(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dictionary_setDay", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Dictionary_setDay" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setDay((std::string const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_has(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dictionary_has", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Dictionary_has" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Dictionary const *)arg1)->has((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_merge(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dictionary_merge", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Dictionary_merge" "', argument " "2"" of type '" "FIX::Dictionary const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Dictionary * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->merge((FIX::Dictionary const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< std::string,std::string >::const_iterator > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::Dictionary const *)arg1)->begin();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::Dictionary::iterator(result)), SWIGTYPE_p_std__mapT_std__string_std__string_t__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< std::string,std::string >::const_iterator > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::Dictionary const *)arg1)->end();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::Dictionary::iterator(result)), SWIGTYPE_p_std__mapT_std__string_std__string_t__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dictionary_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Dictionary, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dictionary_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_BEGINSTRING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BEGINSTRING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BEGINSTRING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BEGINSTRING);
  return pyobj;
}


SWIGINTERN int Swig_var_SENDERCOMPID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SENDERCOMPID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SENDERCOMPID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SENDERCOMPID);
  return pyobj;
}


SWIGINTERN int Swig_var_TARGETCOMPID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TARGETCOMPID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TARGETCOMPID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TARGETCOMPID);
  return pyobj;
}


SWIGINTERN int Swig_var_SESSION_QUALIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SESSION_QUALIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SESSION_QUALIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SESSION_QUALIFIER);
  return pyobj;
}


SWIGINTERN int Swig_var_DEFAULT_APPLVERID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DEFAULT_APPLVERID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DEFAULT_APPLVERID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DEFAULT_APPLVERID);
  return pyobj;
}


SWIGINTERN int Swig_var_CONNECTION_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CONNECTION_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CONNECTION_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CONNECTION_TYPE);
  return pyobj;
}


SWIGINTERN int Swig_var_USE_DATA_DICTIONARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable USE_DATA_DICTIONARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_USE_DATA_DICTIONARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::USE_DATA_DICTIONARY);
  return pyobj;
}


SWIGINTERN int Swig_var_SEND_RESETSEQNUMFLAG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SEND_RESETSEQNUMFLAG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SEND_RESETSEQNUMFLAG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SEND_RESETSEQNUMFLAG);
  return pyobj;
}


SWIGINTERN int Swig_var_SEND_REDUNDANT_RESENDREQUESTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SEND_REDUNDANT_RESENDREQUESTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SEND_REDUNDANT_RESENDREQUESTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SEND_REDUNDANT_RESENDREQUESTS);
  return pyobj;
}


SWIGINTERN int Swig_var_SEND_NEXT_EXPECTED_MSG_SEQ_NUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SEND_NEXT_EXPECTED_MSG_SEQ_NUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SEND_NEXT_EXPECTED_MSG_SEQ_NUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SEND_NEXT_EXPECTED_MSG_SEQ_NUM);
  return pyobj;
}


SWIGINTERN int Swig_var_DATA_DICTIONARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DATA_DICTIONARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DATA_DICTIONARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DATA_DICTIONARY);
  return pyobj;
}


SWIGINTERN int Swig_var_TRANSPORT_DATA_DICTIONARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TRANSPORT_DATA_DICTIONARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TRANSPORT_DATA_DICTIONARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TRANSPORT_DATA_DICTIONARY);
  return pyobj;
}


SWIGINTERN int Swig_var_APP_DATA_DICTIONARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable APP_DATA_DICTIONARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_APP_DATA_DICTIONARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::APP_DATA_DICTIONARY);
  return pyobj;
}


SWIGINTERN int Swig_var_USE_LOCAL_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable USE_LOCAL_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_USE_LOCAL_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::USE_LOCAL_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_START_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable START_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_START_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::START_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_END_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable END_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_END_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::END_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_START_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable START_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_START_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::START_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_END_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable END_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_END_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::END_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_NON_STOP_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NON_STOP_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NON_STOP_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::NON_STOP_SESSION);
  return pyobj;
}


SWIGINTERN int Swig_var_LOGON_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGON_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LOGON_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGON_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_LOGOUT_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGOUT_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LOGOUT_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGOUT_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_LOGON_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGON_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LOGON_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGON_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_LOGOUT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGOUT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LOGOUT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGOUT_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_CHECK_COMPID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CHECK_COMPID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CHECK_COMPID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CHECK_COMPID);
  return pyobj;
}


SWIGINTERN int Swig_var_CHECK_LATENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CHECK_LATENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CHECK_LATENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CHECK_LATENCY);
  return pyobj;
}


SWIGINTERN int Swig_var_MAX_LATENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MAX_LATENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MAX_LATENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MAX_LATENCY);
  return pyobj;
}


SWIGINTERN int Swig_var_HEARTBTINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HEARTBTINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HEARTBTINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::HEARTBTINT);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_ACCEPT_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_ACCEPT_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_ACCEPT_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_ACCEPT_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_REUSE_ADDRESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_REUSE_ADDRESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_REUSE_ADDRESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_REUSE_ADDRESS);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_CONNECT_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_CONNECT_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_CONNECT_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_CONNECT_HOST);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_CONNECT_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_CONNECT_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_CONNECT_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_CONNECT_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_CONNECT_SOURCE_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_CONNECT_SOURCE_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_CONNECT_SOURCE_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_CONNECT_SOURCE_HOST);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_CONNECT_SOURCE_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_CONNECT_SOURCE_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_CONNECT_SOURCE_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_CONNECT_SOURCE_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_NODELAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_NODELAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_NODELAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_NODELAY);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_SEND_BUFFER_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_SEND_BUFFER_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_SEND_BUFFER_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_SEND_BUFFER_SIZE);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_RECEIVE_BUFFER_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_RECEIVE_BUFFER_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_RECEIVE_BUFFER_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_RECEIVE_BUFFER_SIZE);
  return pyobj;
}


SWIGINTERN int Swig_var_HOST_SELECTION_POLICY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HOST_SELECTION_POLICY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HOST_SELECTION_POLICY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::HOST_SELECTION_POLICY);
  return pyobj;
}


SWIGINTERN int Swig_var_HOST_SELECTION_POLICY_PRIORITY_START_OVER_INTERVAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HOST_SELECTION_POLICY_PRIORITY_START_OVER_INTERVAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HOST_SELECTION_POLICY_PRIORITY_START_OVER_INTERVAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::HOST_SELECTION_POLICY_PRIORITY_START_OVER_INTERVAL);
  return pyobj;
}


SWIGINTERN int Swig_var_RECONNECT_INTERVAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RECONNECT_INTERVAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RECONNECT_INTERVAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RECONNECT_INTERVAL);
  return pyobj;
}


SWIGINTERN int Swig_var_VALIDATE_LENGTH_AND_CHECKSUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VALIDATE_LENGTH_AND_CHECKSUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VALIDATE_LENGTH_AND_CHECKSUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::VALIDATE_LENGTH_AND_CHECKSUM);
  return pyobj;
}


SWIGINTERN int Swig_var_VALIDATE_FIELDS_OUT_OF_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VALIDATE_FIELDS_OUT_OF_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VALIDATE_FIELDS_OUT_OF_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::VALIDATE_FIELDS_OUT_OF_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_VALIDATE_FIELDS_HAVE_VALUES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VALIDATE_FIELDS_HAVE_VALUES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VALIDATE_FIELDS_HAVE_VALUES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::VALIDATE_FIELDS_HAVE_VALUES);
  return pyobj;
}


SWIGINTERN int Swig_var_VALIDATE_USER_DEFINED_FIELDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VALIDATE_USER_DEFINED_FIELDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VALIDATE_USER_DEFINED_FIELDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::VALIDATE_USER_DEFINED_FIELDS);
  return pyobj;
}


SWIGINTERN int Swig_var_ALLOW_UNKNOWN_MSG_FIELDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ALLOW_UNKNOWN_MSG_FIELDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ALLOW_UNKNOWN_MSG_FIELDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ALLOW_UNKNOWN_MSG_FIELDS);
  return pyobj;
}


SWIGINTERN int Swig_var_PRESERVE_MESSAGE_FIELDS_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PRESERVE_MESSAGE_FIELDS_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PRESERVE_MESSAGE_FIELDS_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PRESERVE_MESSAGE_FIELDS_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_LOGON_TIMEOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGON_TIMEOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LOGON_TIMEOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGON_TIMEOUT);
  return pyobj;
}


SWIGINTERN int Swig_var_LOGOUT_TIMEOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGOUT_TIMEOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LOGOUT_TIMEOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGOUT_TIMEOUT);
  return pyobj;
}


SWIGINTERN int Swig_var_FILE_STORE_PATH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FILE_STORE_PATH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FILE_STORE_PATH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FILE_STORE_PATH);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_STORE_USECONNECTIONPOOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_USECONNECTIONPOOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_STORE_USECONNECTIONPOOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_USECONNECTIONPOOL);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_STORE_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_STORE_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_DATABASE);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_STORE_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_STORE_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_USER);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_STORE_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_STORE_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_PASSWORD);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_STORE_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_STORE_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_HOST);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_STORE_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_STORE_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_STORE_USECONNECTIONPOOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_USECONNECTIONPOOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_STORE_USECONNECTIONPOOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_USECONNECTIONPOOL);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_STORE_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_STORE_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_DATABASE);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_STORE_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_STORE_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_USER);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_STORE_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_STORE_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_PASSWORD);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_STORE_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_STORE_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_HOST);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_STORE_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_STORE_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_STORE_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_STORE_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_STORE_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_STORE_USER);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_STORE_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_STORE_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_STORE_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_STORE_PASSWORD);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_STORE_CONNECTION_STRING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_STORE_CONNECTION_STRING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_STORE_CONNECTION_STRING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_STORE_CONNECTION_STRING);
  return pyobj;
}


SWIGINTERN int Swig_var_FILE_LOG_PATH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FILE_LOG_PATH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FILE_LOG_PATH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FILE_LOG_PATH);
  return pyobj;
}


SWIGINTERN int Swig_var_FILE_LOG_BACKUP_PATH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FILE_LOG_BACKUP_PATH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FILE_LOG_BACKUP_PATH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FILE_LOG_BACKUP_PATH);
  return pyobj;
}


SWIGINTERN int Swig_var_SCREEN_LOG_SHOW_INCOMING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SCREEN_LOG_SHOW_INCOMING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SCREEN_LOG_SHOW_INCOMING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_INCOMING);
  return pyobj;
}


SWIGINTERN int Swig_var_SCREEN_LOG_SHOW_OUTGOING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SCREEN_LOG_SHOW_OUTGOING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SCREEN_LOG_SHOW_OUTGOING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_OUTGOING);
  return pyobj;
}


SWIGINTERN int Swig_var_SCREEN_LOG_SHOW_EVENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SCREEN_LOG_SHOW_EVENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SCREEN_LOG_SHOW_EVENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_EVENTS);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_USECONNECTIONPOOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_USECONNECTIONPOOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_USECONNECTIONPOOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_USECONNECTIONPOOL);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_DATABASE);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_USER);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_PASSWORD);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_HOST);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_INCOMING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_INCOMING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_INCOMING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_INCOMING_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_OUTGOING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_OUTGOING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_OUTGOING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_OUTGOING_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_EVENT_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_EVENT_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_EVENT_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_EVENT_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_USECONNECTIONPOOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_USECONNECTIONPOOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_USECONNECTIONPOOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_USECONNECTIONPOOL);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_DATABASE);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_USER);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_PASSWORD);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_HOST);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_INCOMING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_INCOMING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_INCOMING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_INCOMING_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_OUTGOING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_OUTGOING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_OUTGOING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_OUTGOING_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_EVENT_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_EVENT_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_EVENT_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_EVENT_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_LOG_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_LOG_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_USER);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_LOG_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_LOG_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_PASSWORD);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_LOG_CONNECTION_STRING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_CONNECTION_STRING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_LOG_CONNECTION_STRING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_CONNECTION_STRING);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_LOG_INCOMING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_INCOMING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_LOG_INCOMING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_INCOMING_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_LOG_OUTGOING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_OUTGOING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_LOG_OUTGOING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_OUTGOING_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_LOG_EVENT_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_EVENT_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_LOG_EVENT_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_EVENT_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_RESET_ON_LOGON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RESET_ON_LOGON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RESET_ON_LOGON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RESET_ON_LOGON);
  return pyobj;
}


SWIGINTERN int Swig_var_RESET_ON_LOGOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RESET_ON_LOGOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RESET_ON_LOGOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RESET_ON_LOGOUT);
  return pyobj;
}


SWIGINTERN int Swig_var_RESET_ON_DISCONNECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RESET_ON_DISCONNECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RESET_ON_DISCONNECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RESET_ON_DISCONNECT);
  return pyobj;
}


SWIGINTERN int Swig_var_REFRESH_ON_LOGON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable REFRESH_ON_LOGON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_REFRESH_ON_LOGON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::REFRESH_ON_LOGON);
  return pyobj;
}


SWIGINTERN int Swig_var_MILLISECONDS_IN_TIMESTAMP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MILLISECONDS_IN_TIMESTAMP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MILLISECONDS_IN_TIMESTAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MILLISECONDS_IN_TIMESTAMP);
  return pyobj;
}


SWIGINTERN int Swig_var_TIMESTAMP_PRECISION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TIMESTAMP_PRECISION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TIMESTAMP_PRECISION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TIMESTAMP_PRECISION);
  return pyobj;
}


SWIGINTERN int Swig_var_HTTP_ACCEPT_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HTTP_ACCEPT_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HTTP_ACCEPT_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::HTTP_ACCEPT_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_PERSIST_MESSAGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PERSIST_MESSAGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PERSIST_MESSAGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PERSIST_MESSAGES);
  return pyobj;
}


SWIGINTERN int Swig_var_SERVER_CERTIFICATE_FILE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SERVER_CERTIFICATE_FILE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SERVER_CERTIFICATE_FILE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SERVER_CERTIFICATE_FILE);
  return pyobj;
}


SWIGINTERN int Swig_var_SERVER_CERTIFICATE_KEY_FILE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SERVER_CERTIFICATE_KEY_FILE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SERVER_CERTIFICATE_KEY_FILE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SERVER_CERTIFICATE_KEY_FILE);
  return pyobj;
}


SWIGINTERN int Swig_var_CLIENT_CERTIFICATE_FILE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CLIENT_CERTIFICATE_FILE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CLIENT_CERTIFICATE_FILE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CLIENT_CERTIFICATE_FILE);
  return pyobj;
}


SWIGINTERN int Swig_var_CLIENT_CERTIFICATE_KEY_FILE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CLIENT_CERTIFICATE_KEY_FILE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CLIENT_CERTIFICATE_KEY_FILE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CLIENT_CERTIFICATE_KEY_FILE);
  return pyobj;
}


SWIGINTERN int Swig_var_CERTIFICATE_AUTHORITIES_FILE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CERTIFICATE_AUTHORITIES_FILE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CERTIFICATE_AUTHORITIES_FILE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CERTIFICATE_AUTHORITIES_FILE);
  return pyobj;
}


SWIGINTERN int Swig_var_CERTIFICATE_AUTHORITIES_DIRECTORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CERTIFICATE_AUTHORITIES_DIRECTORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CERTIFICATE_AUTHORITIES_DIRECTORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CERTIFICATE_AUTHORITIES_DIRECTORY);
  return pyobj;
}


SWIGINTERN int Swig_var_CERTIFICATE_REVOCATION_LIST_FILE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CERTIFICATE_REVOCATION_LIST_FILE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CERTIFICATE_REVOCATION_LIST_FILE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CERTIFICATE_REVOCATION_LIST_FILE);
  return pyobj;
}


SWIGINTERN int Swig_var_CERTIFICATE_REVOCATION_LIST_DIRECTORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CERTIFICATE_REVOCATION_LIST_DIRECTORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CERTIFICATE_REVOCATION_LIST_DIRECTORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CERTIFICATE_REVOCATION_LIST_DIRECTORY);
  return pyobj;
}


SWIGINTERN int Swig_var_CERTIFICATE_VERIFY_LEVEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CERTIFICATE_VERIFY_LEVEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CERTIFICATE_VERIFY_LEVEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CERTIFICATE_VERIFY_LEVEL);
  return pyobj;
}


SWIGINTERN int Swig_var_ALLOWED_REMOTE_ADDRESSES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ALLOWED_REMOTE_ADDRESSES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ALLOWED_REMOTE_ADDRESSES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ALLOWED_REMOTE_ADDRESSES);
  return pyobj;
}


SWIGINTERN int Swig_var_SSL_PROTOCOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SSL_PROTOCOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SSL_PROTOCOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SSL_PROTOCOL);
  return pyobj;
}


SWIGINTERN int Swig_var_SSL_CIPHER_SUITE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SSL_CIPHER_SUITE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SSL_CIPHER_SUITE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SSL_CIPHER_SUITE);
  return pyobj;
}


SWIGINTERN int Swig_var_TLS_CIPHER_SUITES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TLS_CIPHER_SUITES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TLS_CIPHER_SUITES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TLS_CIPHER_SUITES);
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_SessionSettings__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SessionSettings *)new FIX::SessionSettings();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionSettings__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  FIX::SessionSettings *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_SessionSettings" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SessionSettings" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SessionSettings *)new FIX::SessionSettings(*arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionSettings__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::SessionSettings *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_SessionSettings" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SessionSettings *)new FIX::SessionSettings(*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionSettings__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  FIX::SessionSettings *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_SessionSettings" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SessionSettings" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SessionSettings *)new FIX::SessionSettings((std::string const &)*arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionSettings__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::SessionSettings *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_SessionSettings" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SessionSettings *)new FIX::SessionSettings((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionSettings(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SessionSettings", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SessionSettings__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SessionSettings__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SessionSettings__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SessionSettings__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SessionSettings__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SessionSettings'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SessionSettings::SessionSettings()\n"
    "    FIX::SessionSettings::SessionSettings(std::istream &,bool)\n"
    "    FIX::SessionSettings::SessionSettings(std::istream &)\n"
    "    FIX::SessionSettings::SessionSettings(std::string const &,bool)\n"
    "    FIX::SessionSettings::SessionSettings(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SessionSettings_has(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionSettings_has", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "SessionSettings_has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::SessionSettings const *)arg1)->has((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FIX::Dictionary *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "SessionSettings_get" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Dictionary *) &((FIX::SessionSettings const *)arg1)->get((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "SessionSettings_set" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "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;
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->set((FIX::SessionID const &)*arg2,SWIG_STD_MOVE(arg3));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Dictionary *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Dictionary *) &((FIX::SessionSettings const *)arg1)->get();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SessionSettings_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SessionSettings_get__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SessionSettings_get__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SessionSettings_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SessionSettings::get(FIX::SessionID const &) const\n"
    "    FIX::SessionSettings::get() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SessionSettings_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "SessionSettings_set" "', argument " "2"" of type '" "FIX::Dictionary const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Dictionary * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->set((FIX::Dictionary const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SessionSettings_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__Dictionary, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SessionSettings_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__Dictionary, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SessionSettings_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SessionSettings_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SessionSettings::set(FIX::SessionID const &,FIX::Dictionary)\n"
    "    FIX::SessionSettings::set(FIX::Dictionary const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SessionSettings_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::SessionSettings const *)arg1)->size();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_getSessions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::SessionSettings const *)arg1)->getSessions();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___rshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  FIX::SessionSettings *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::istream *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__rshift__" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__rshift__" "', argument " "2"" of type '" "FIX::SessionSettings &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionSettings * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::istream *) &operator >>(*arg1,*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__istream, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___rshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__rshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___rshift____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___rshift____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lshift____SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  FIX::SessionSettings *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionSettings * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::ostream *) &operator <<(*arg1,(FIX::SessionSettings const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__FieldBase, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__Message, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SessionSettings_setFromString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SessionSettings_setFromString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionSettings_setFromString" "', argument " "1"" of type '" "FIX::SessionSettings *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionSettings_setFromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SessionSettings_setFromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            FIX_SessionSettings_setFromString(arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SessionSettings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SessionSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SessionSettings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SessionSettings_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Session(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::function< FIX::UtcTimeStamp () > > arg1 ;
  Application *arg2 = 0 ;
  MessageStoreFactory *arg3 = 0 ;
  FIX::SessionID *arg4 = 0 ;
  DataDictionaryProvider *arg5 = 0 ;
  TimeRange *arg6 = 0 ;
  int arg7 ;
  LogFactory *arg8 = (LogFactory *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject *swig_obj[8] ;
  FIX::Session *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Session", 8, 8, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__functionT_FIX__UtcTimeStamp_fF_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Session" "', argument " "1"" of type '" "std::function< FIX::UtcTimeStamp () >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Session" "', argument " "1"" of type '" "std::function< FIX::UtcTimeStamp () >""'");
    } else {
      std::function< FIX::UtcTimeStamp () > * temp = reinterpret_cast< std::function< FIX::UtcTimeStamp () > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Application,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Session" "', argument " "2"" of type '" "Application &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Session" "', argument " "2"" of type '" "Application &""'"); 
  }
  arg2 = reinterpret_cast< Application * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Session" "', argument " "3"" of type '" "MessageStoreFactory &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Session" "', argument " "3"" of type '" "MessageStoreFactory &""'"); 
  }
  arg3 = reinterpret_cast< MessageStoreFactory * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Session" "', argument " "4"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Session" "', argument " "4"" of type '" "FIX::SessionID const &""'"); 
  }
  arg4 = reinterpret_cast< FIX::SessionID * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DataDictionaryProvider,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Session" "', argument " "5"" of type '" "DataDictionaryProvider const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Session" "', argument " "5"" of type '" "DataDictionaryProvider const &""'"); 
  }
  arg5 = reinterpret_cast< DataDictionaryProvider * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_TimeRange,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Session" "', argument " "6"" of type '" "TimeRange const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Session" "', argument " "6"" of type '" "TimeRange const &""'"); 
  }
  arg6 = reinterpret_cast< TimeRange * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Session" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_LogFactory, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_Session" "', argument " "8"" of type '" "LogFactory *""'"); 
  }
  arg8 = reinterpret_cast< LogFactory * >(argp8);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Session *)new FIX::Session(SWIG_STD_MOVE(arg1),*arg2,*arg3,(FIX::SessionID const &)*arg4,(DataDictionaryProvider const &)*arg5,(TimeRange const &)*arg6,arg7,arg8);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Session(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_logon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->logon();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_logout__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Session_logout" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->logout((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_logout__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->logout();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_logout(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Session_logout", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Session_logout__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Session_logout__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Session_logout'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Session::logout(std::string const &)\n"
    "    FIX::Session::logout()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Session_isEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->isEnabled();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sentLogon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->sentLogon();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sentLogout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->sentLogout();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_receivedLogon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->receivedLogon();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isLoggedOn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->isLoggedOn();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->reset();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_refresh(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->refresh();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setNextSenderMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setNextSenderMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextSenderMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setNextTargetMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setNextTargetMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextTargetMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getSessionID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SessionID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SessionID *) &((FIX::Session const *)arg1)->getSessionID();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setDataDictionaryProvider(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setDataDictionaryProvider", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Session_setDataDictionaryProvider" "', argument " "2"" of type '" "DataDictionaryProvider const &""'"); 
  }
  arg2 = reinterpret_cast< DataDictionaryProvider * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setDataDictionaryProvider((DataDictionaryProvider const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getDataDictionaryProvider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DataDictionaryProvider *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (DataDictionaryProvider *) &((FIX::Session const *)arg1)->getDataDictionaryProvider();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DataDictionaryProvider, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Session::sendToTarget(*arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_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_NullReferenceError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Session::sendToTarget(*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_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_NullReferenceError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Session::sendToTarget(*arg1,(FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  FIX::SenderCompID *arg2 = 0 ;
  FIX::TargetCompID *arg3 = 0 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "2"" of type '" "FIX::SenderCompID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SenderCompID * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "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(swig_obj[3], &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_NullReferenceError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Session::sendToTarget(*arg1,(FIX::SenderCompID const &)*arg2,(FIX::TargetCompID const &)*arg3,(std::string const &)*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  FIX::SenderCompID *arg2 = 0 ;
  FIX::TargetCompID *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "2"" of type '" "FIX::SenderCompID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SenderCompID * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "3"" of type '" "FIX::TargetCompID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::TargetCompID * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Session::sendToTarget(*arg1,(FIX::SenderCompID const &)*arg2,(FIX::TargetCompID const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "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(swig_obj[2], &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_NullReferenceError, "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(swig_obj[3], &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_NullReferenceError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Session::sendToTarget(*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "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(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Session::sendToTarget(*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Session_sendToTarget", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Session_sendToTarget__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Session_sendToTarget__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Session_sendToTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SenderCompID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__TargetCompID, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Session_sendToTarget__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Session_sendToTarget__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SenderCompID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__TargetCompID, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Session_sendToTarget__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Session_sendToTarget__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Session_sendToTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Session::sendToTarget(FIX::Message &,std::string const &)\n"
    "    FIX::Session::sendToTarget(FIX::Message &)\n"
    "    FIX::Session::sendToTarget(FIX::Message &,FIX::SessionID const &)\n"
    "    FIX::Session::sendToTarget(FIX::Message &,FIX::SenderCompID const &,FIX::TargetCompID const &,std::string const &)\n"
    "    FIX::Session::sendToTarget(FIX::Message &,FIX::SenderCompID const &,FIX::TargetCompID const &)\n"
    "    FIX::Session::sendToTarget(FIX::Message &,std::string const &,std::string const &,std::string const &)\n"
    "    FIX::Session::sendToTarget(FIX::Message &,std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Session_getSessions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_getSessions", 0, 0, 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::Session::getSessions();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_doesSessionExist(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_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_NullReferenceError, "invalid null reference " "in method '" "Session_doesSessionExist" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Session::doesSessionExist((FIX::SessionID const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_lookupSession__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Session *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "Session_lookupSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Session *)FIX::Session::lookupSession((FIX::SessionID const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_lookupSession__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  FIX::Session *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "Session_lookupSession" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Session *)FIX::Session::lookupSession((std::string const &)*arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_lookupSession__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::Session *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "Session_lookupSession" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Session *)FIX::Session::lookupSession((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_lookupSession(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Session_lookupSession", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Session_lookupSession__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Session_lookupSession__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Session_lookupSession__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Session_lookupSession'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Session::lookupSession(FIX::SessionID const &)\n"
    "    FIX::Session::lookupSession(std::string const &,bool)\n"
    "    FIX::Session::lookupSession(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Session_isSessionRegistered(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_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_NullReferenceError, "invalid null reference " "in method '" "Session_isSessionRegistered" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Session::isSessionRegistered((FIX::SessionID const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_registerSession(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::Session *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "Session_registerSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Session *)FIX::Session::registerSession((FIX::SessionID const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_unregisterSession(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_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_NullReferenceError, "invalid null reference " "in method '" "Session_unregisterSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            FIX::Session::unregisterSession((FIX::SessionID const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_numSessions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_numSessions", 0, 0, 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = FIX::Session::numSessions();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isSessionTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_isSessionTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_isSessionTime" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Session_isSessionTime" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->isSessionTime((FIX::UtcTimeStamp const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isLogonTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_isLogonTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_isLogonTime" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Session_isLogonTime" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->isLogonTime((FIX::UtcTimeStamp const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isInitiator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->isInitiator();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isAcceptor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->isAcceptor();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getLogonTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TimeRange *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (TimeRange *) &(arg1)->getLogonTime();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeRange, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setLogonTime(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setLogonTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Session_setLogonTime" "', argument " "2"" of type '" "TimeRange const &""'"); 
  }
  arg2 = reinterpret_cast< TimeRange * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setLogonTime((TimeRange const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getSenderDefaultApplVerID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &(arg1)->getSenderDefaultApplVerID();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setSenderDefaultApplVerID(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setSenderDefaultApplVerID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Session_setSenderDefaultApplVerID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setSenderDefaultApplVerID((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getTargetDefaultApplVerID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &(arg1)->getTargetDefaultApplVerID();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setTargetDefaultApplVerID(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setTargetDefaultApplVerID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Session_setTargetDefaultApplVerID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setTargetDefaultApplVerID((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getSendRedundantResendRequests(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->getSendRedundantResendRequests();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setSendRedundantResendRequests(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setSendRedundantResendRequests", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setSendRedundantResendRequests(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getCheckCompId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->getCheckCompId();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setCheckCompId(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setCheckCompId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setCheckCompId(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getCheckLatency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->getCheckLatency();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setCheckLatency(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setCheckLatency", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setCheckLatency(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getMaxLatency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)(arg1)->getMaxLatency();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setMaxLatency(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setMaxLatency", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setMaxLatency(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getLogonTimeout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)(arg1)->getLogonTimeout();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setLogonTimeout(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setLogonTimeout", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setLogonTimeout(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getLogoutTimeout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)(arg1)->getLogoutTimeout();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setLogoutTimeout(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setLogoutTimeout", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setLogoutTimeout(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getResetOnLogon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->getResetOnLogon();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setResetOnLogon(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setResetOnLogon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setResetOnLogon(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getResetOnLogout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->getResetOnLogout();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setResetOnLogout(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setResetOnLogout", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setResetOnLogout(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getResetOnDisconnect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->getResetOnDisconnect();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setResetOnDisconnect(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setResetOnDisconnect", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setResetOnDisconnect(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getRefreshOnLogon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->getRefreshOnLogon();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setRefreshOnLogon(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setRefreshOnLogon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setRefreshOnLogon(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getMillisecondsInTimeStamp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->getMillisecondsInTimeStamp();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setMillisecondsInTimeStamp(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setMillisecondsInTimeStamp", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setMillisecondsInTimeStamp(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getTimestampPrecision(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getTimestampPrecision" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)(arg1)->getTimestampPrecision();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setTimestampPrecision(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setTimestampPrecision", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setTimestampPrecision" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setTimestampPrecision" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setTimestampPrecision(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getSupportedTimestampPrecision(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getSupportedTimestampPrecision" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)(arg1)->getSupportedTimestampPrecision();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_supportsSubSecondTimestamps(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_supportsSubSecondTimestamps" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Session_supportsSubSecondTimestamps" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)FIX::Session::supportsSubSecondTimestamps((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getPersistMessages(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->getPersistMessages();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setPersistMessages(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setPersistMessages", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setPersistMessages(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getValidateLengthAndChecksum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getValidateLengthAndChecksum" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->getValidateLengthAndChecksum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setValidateLengthAndChecksum(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setValidateLengthAndChecksum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setValidateLengthAndChecksum" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setValidateLengthAndChecksum" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setValidateLengthAndChecksum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getSendNextExpectedMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getSendNextExpectedMsgSeqNum" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->getSendNextExpectedMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setSendNextExpectedMsgSeqNum(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setSendNextExpectedMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setSendNextExpectedMsgSeqNum" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setSendNextExpectedMsgSeqNum" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setSendNextExpectedMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getIsNonStopSession(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getIsNonStopSession" "', argument " "1"" of type '" "FIX::Session const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Session const *)arg1)->getIsNonStopSession();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setIsNonStopSession(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setIsNonStopSession", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setIsNonStopSession" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setIsNonStopSession" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setIsNonStopSession(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getAllowedRemoteAddresses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< std::string,std::less< std::string >,std::allocator< std::string > > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getAllowedRemoteAddresses" "', argument " "1"" of type '" "FIX::Session const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::set< std::string,std::less< std::string >,std::allocator< std::string > > *) &((FIX::Session const *)arg1)->getAllowedRemoteAddresses();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_std__string_std__lessT_std__string_t_std__allocatorT_std__string_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setAllowedRemoteAddresses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  std::set< std::string,std::less< std::string >,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setAllowedRemoteAddresses", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setAllowedRemoteAddresses" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__setT_std__string_std__lessT_std__string_t_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_setAllowedRemoteAddresses" "', argument " "2"" of type '" "std::set< std::string,std::less< std::string >,std::allocator< std::string > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Session_setAllowedRemoteAddresses" "', argument " "2"" of type '" "std::set< std::string,std::less< std::string >,std::allocator< std::string > > const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< std::string,std::less< std::string >,std::allocator< std::string > > * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setAllowedRemoteAddresses((std::set< std::string,std::less< std::string >,std::allocator< std::string > > const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_inAllowedRemoteAddresses(PyObject *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 *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_inAllowedRemoteAddresses", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_inAllowedRemoteAddresses" "', argument " "1"" of type '" "FIX::Session const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_inAllowedRemoteAddresses" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Session_inAllowedRemoteAddresses" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Session const *)arg1)->inAllowedRemoteAddresses((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setResponder(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_setResponder", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setResponder(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_send(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::Message *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Session_send", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Session_send" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->send(*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_next__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_next" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Session_next" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->next((FIX::UtcTimeStamp const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_next__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  std::string *arg2 = 0 ;
  FIX::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 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Session_next" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Session_next" "', argument " "3"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Session_next" "', argument " "3"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::UtcTimeStamp * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->next((std::string const &)*arg2,(FIX::UtcTimeStamp const &)*arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_next__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  std::string *arg2 = 0 ;
  FIX::UtcTimeStamp *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Session_next" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Session_next" "', argument " "3"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Session_next" "', argument " "3"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::UtcTimeStamp * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->next((std::string const &)*arg2,(FIX::UtcTimeStamp const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_next__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::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 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Session_next" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Session_next" "', argument " "3"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Session_next" "', argument " "3"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::UtcTimeStamp * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->next((FIX::Message const &)*arg2,(FIX::UtcTimeStamp const &)*arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_next__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::UtcTimeStamp *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Session_next" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Session_next" "', argument " "3"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Session_next" "', argument " "3"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::UtcTimeStamp * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->next((FIX::Message const &)*arg2,(FIX::UtcTimeStamp const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_next(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Session_next", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    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__UtcTimeStamp, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Session_next__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Session_next__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    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_FIX__UtcTimeStamp, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Session_next__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Session_next__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    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_FIX__UtcTimeStamp, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Session_next__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Session_next'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Session::next(FIX::UtcTimeStamp const &)\n"
    "    FIX::Session::next(std::string const &,FIX::UtcTimeStamp const &,bool)\n"
    "    FIX::Session::next(std::string const &,FIX::UtcTimeStamp const &)\n"
    "    FIX::Session::next(FIX::Message const &,FIX::UtcTimeStamp const &,bool)\n"
    "    FIX::Session::next(FIX::Message const &,FIX::UtcTimeStamp const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Session_disconnect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->disconnect();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getExpectedSenderNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)(arg1)->getExpectedSenderNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getExpectedTargetNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)(arg1)->getExpectedTargetNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Log *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (Log *)(arg1)->getLog();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Log, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getStore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MessageStore *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (MessageStore *)(arg1)->getStore();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MessageStore, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Session_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Session, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Session_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_LogFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LogFactory *arg1 = (FIX::LogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogFactory_create__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::LogFactory *arg1 = (FIX::LogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  FIX::Log *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::LogFactory::create");
            } else {
          result = (FIX::Log *)(arg1)->create();
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogFactory_create__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::LogFactory *arg1 = (FIX::LogFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  FIX::Log *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "LogFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::LogFactory::create");
            } else {
          result = (FIX::Log *)(arg1)->create((FIX::SessionID const &)*arg2);
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogFactory_create(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LogFactory_create", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LogFactory_create__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LogFactory_create__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LogFactory_create'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LogFactory::create()\n"
    "    FIX::LogFactory::create(FIX::SessionID const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LogFactory_destroy(PyObject *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 *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LogFactory_destroy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::LogFactory::destroy");
            } else {
          (arg1)->destroy(arg2);
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  FIX::LogFactory *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            if ( arg1 != Py_None ) {
          /* subclassed */
              result = (FIX::LogFactory *)new SwigDirector_LogFactory(arg1); 
            } else {
          SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
              SWIG_fail;
            }
            
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LogFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_LogFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LogFactory *arg1 = (FIX::LogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__LogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_LogFactory" "', argument " "1"" of type '" "FIX::LogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LogFactory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LogFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LogFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LogFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ScreenLogFactory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionSettings arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  FIX::ScreenLogFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &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""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ScreenLogFactory" "', argument " "1"" of type '" "FIX::SessionSettings""'");
    } else {
      FIX::SessionSettings * temp = reinterpret_cast< FIX::SessionSettings * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::ScreenLogFactory *)new FIX::ScreenLogFactory(SWIG_STD_MOVE(arg1));
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ScreenLogFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScreenLogFactory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  FIX::ScreenLogFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::ScreenLogFactory *)new FIX::ScreenLogFactory(arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ScreenLogFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScreenLogFactory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScreenLogFactory", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ScreenLogFactory__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ScreenLogFactory__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScreenLogFactory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ScreenLogFactory::ScreenLogFactory(FIX::SessionSettings)\n"
    "    FIX::ScreenLogFactory::ScreenLogFactory(bool,bool,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ScreenLogFactory_create__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::ScreenLogFactory *arg1 = (FIX::ScreenLogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Log *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Log *)(arg1)->create();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLogFactory_create__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::ScreenLogFactory *arg1 = (FIX::ScreenLogFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FIX::Log *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "ScreenLogFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Log *)(arg1)->create((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLogFactory_create(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ScreenLogFactory_create", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__ScreenLogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ScreenLogFactory_create__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ScreenLogFactory_create__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ScreenLogFactory_create'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ScreenLogFactory::create()\n"
    "    FIX::ScreenLogFactory::create(FIX::SessionID const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ScreenLogFactory_destroy(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScreenLogFactory_destroy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->destroy(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScreenLogFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLogFactory *arg1 = (FIX::ScreenLogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScreenLogFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ScreenLogFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScreenLogFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_Log(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Log *arg1 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Log_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Log *arg1 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::Log::clear");
            } else {
          (arg1)->clear();
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Log_backup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Log *arg1 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::Log::backup");
            } else {
          (arg1)->backup();
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Log_onIncoming(PyObject *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 *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Log_onIncoming", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Log_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::Log::onIncoming");
            } else {
          (arg1)->onIncoming((std::string const &)*arg2);
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Log_onOutgoing(PyObject *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 *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Log_onOutgoing", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Log_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::Log::onOutgoing");
            } else {
          (arg1)->onOutgoing((std::string const &)*arg2);
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Log_onEvent(PyObject *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 *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Log_onEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Log_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::Log::onEvent");
            } else {
          (arg1)->onEvent((std::string const &)*arg2);
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Log(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  FIX::Log *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            if ( arg1 != Py_None ) {
          /* subclassed */
              result = (FIX::Log *)new SwigDirector_Log(arg1); 
            } else {
          SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
              SWIG_fail;
            }
            
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Log(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Log *arg1 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Log" "', argument " "1"" of type '" "FIX::Log *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Log * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Log, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_NullLog_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullLog *arg1 = (FIX::NullLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->clear();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullLog_backup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullLog *arg1 = (FIX::NullLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->backup();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullLog_onIncoming(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NullLog_onIncoming", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "NullLog_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onIncoming((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullLog_onOutgoing(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NullLog_onOutgoing", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "NullLog_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onOutgoing((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullLog_onEvent(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NullLog_onEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "NullLog_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onEvent((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NullLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullLog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_NullLog", 0, 0, 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::NullLog *)new FIX::NullLog();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NullLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NullLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullLog *arg1 = (FIX::NullLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NullLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NullLog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NullLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ScreenLog__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  FIX::ScreenLog *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::ScreenLog *)new FIX::ScreenLog(arg1,arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ScreenLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScreenLog__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  FIX::ScreenLog *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_ScreenLog" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &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(swig_obj[2], &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(swig_obj[3], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::ScreenLog *)new FIX::ScreenLog((FIX::SessionID const &)*arg1,arg2,arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ScreenLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScreenLog(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScreenLog", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ScreenLog__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ScreenLog__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScreenLog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ScreenLog::ScreenLog(bool,bool,bool)\n"
    "    FIX::ScreenLog::ScreenLog(FIX::SessionID const &,bool,bool,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ScreenLog_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->clear();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLog_backup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->backup();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLog_onIncoming(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScreenLog_onIncoming", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "ScreenLog_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onIncoming((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLog_onOutgoing(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScreenLog_onOutgoing", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "ScreenLog_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onOutgoing((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLog_onEvent(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScreenLog_onEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "ScreenLog_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onEvent((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScreenLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScreenLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ScreenLog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScreenLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FileLogFactory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::FileLogFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_FileLogFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FileLogFactory *)new FIX::FileLogFactory((FIX::SessionSettings const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FileLogFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLogFactory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::FileLogFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_FileLogFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FileLogFactory *)new FIX::FileLogFactory((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLogFactory__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  FIX::FileLogFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_FileLogFactory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FileLogFactory *)new FIX::FileLogFactory((std::string const &)*arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLogFactory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FileLogFactory", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileLogFactory__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileLogFactory__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FileLogFactory__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FileLogFactory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FileLogFactory::FileLogFactory(FIX::SessionSettings const &)\n"
    "    FIX::FileLogFactory::FileLogFactory(std::string const &)\n"
    "    FIX::FileLogFactory::FileLogFactory(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FileLogFactory_create__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FileLogFactory *arg1 = (FIX::FileLogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  FIX::Log *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Log *)(arg1)->create();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLogFactory_create__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::FileLogFactory *arg1 = (FIX::FileLogFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  FIX::Log *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "FileLogFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Log *)(arg1)->create((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLogFactory_create(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FileLogFactory_create", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FileLogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FileLogFactory_create__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FileLogFactory_create__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FileLogFactory_create'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FileLogFactory::create()\n"
    "    FIX::FileLogFactory::create(FIX::SessionID const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FileLogFactory_destroy(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileLogFactory_destroy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->destroy(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FileLogFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLogFactory *arg1 = (FIX::FileLogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FileLogFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FileLogFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FileLogFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FileLog__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::FileLog *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_FileLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FileLog *)new FIX::FileLog((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLog__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  FIX::FileLog *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_FileLog" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FileLog *)new FIX::FileLog((std::string const &)*arg1,(std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLog__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FIX::FileLog *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_FileLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_FileLog" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FileLog *)new FIX::FileLog((std::string const &)*arg1,(FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLog__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  FIX::SessionID *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::FileLog *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_FileLog" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "new_FileLog" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        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;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLog(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FileLog", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileLog__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FileLog__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FileLog__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FileLog__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FileLog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FileLog::FileLog(std::string const &)\n"
    "    FIX::FileLog::FileLog(std::string const &,std::string const &)\n"
    "    FIX::FileLog::FileLog(std::string const &,FIX::SessionID const &)\n"
    "    FIX::FileLog::FileLog(std::string const &,std::string const &,FIX::SessionID const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FileLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLog_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->clear();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLog_backup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->backup();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLog_onIncoming(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileLog_onIncoming", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "FileLog_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onIncoming((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLog_onOutgoing(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileLog_onOutgoing", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "FileLog_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onOutgoing((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLog_onEvent(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileLog_onEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "FileLog_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onEvent((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *FileLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FileLog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FileLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_MessageStoreFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreFactory *arg1 = (FIX::MessageStoreFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreFactory_create(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreFactory *arg1 = (FIX::MessageStoreFactory *) 0 ;
  FIX::UtcTimeStamp *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 *swig_obj[3] ;
  FIX::MessageStore *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreFactory_create", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStoreFactory_create" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MessageStoreFactory_create" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MessageStoreFactory_create" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MessageStoreFactory_create" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MessageStore *)(arg1)->create((FIX::UtcTimeStamp const &)*arg2,(FIX::SessionID const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreFactory_destroy(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreFactory_destroy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->destroy(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MessageStoreFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_MemoryStoreFactory_create(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStoreFactory *arg1 = (FIX::MemoryStoreFactory *) 0 ;
  FIX::UtcTimeStamp *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 *swig_obj[3] ;
  FIX::MessageStore *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MemoryStoreFactory_create", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryStoreFactory_create" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MemoryStoreFactory_create" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MemoryStoreFactory_create" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MemoryStoreFactory_create" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MessageStore *)(arg1)->create((FIX::UtcTimeStamp const &)*arg2,(FIX::SessionID const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStoreFactory_destroy(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MemoryStoreFactory_destroy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->destroy(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MemoryStoreFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStoreFactory *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_MemoryStoreFactory", 0, 0, 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MemoryStoreFactory *)new FIX::MemoryStoreFactory();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MemoryStoreFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MemoryStoreFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStoreFactory *arg1 = (FIX::MemoryStoreFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MemoryStoreFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MemoryStoreFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MemoryStoreFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_MessageStore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  FIX::SEQNUM arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStore_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStore_set" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  FIX::SEQNUM arg2 ;
  FIX::SEQNUM arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStore_get", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStore_get" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageStore_get" "', argument " "3"" of type '" "FIX::SEQNUM""'");
  } 
  arg3 = static_cast< FIX::SEQNUM >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageStore_get" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MessageStore_get" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            ((FIX::MessageStore const *)arg1)->get(arg2,arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_getNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)((FIX::MessageStore const *)arg1)->getNextSenderMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_getNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)((FIX::MessageStore const *)arg1)->getNextTargetMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_setNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStore_setNextSenderMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStore_setNextSenderMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextSenderMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_setNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStore_setNextTargetMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStore_setNextTargetMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextTargetMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_incrNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->incrNextSenderMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_incrNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->incrNextTargetMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_getCreationTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::UtcTimeStamp result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::MessageStore const *)arg1)->getCreationTime();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::UtcTimeStamp(result)), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStore_reset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStore_reset" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MessageStore_reset" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->reset((FIX::UtcTimeStamp const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_refresh(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->refresh();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MessageStore_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MessageStore, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MemoryStore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStamp *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::MemoryStore *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MemoryStore" "', argument " "1"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MemoryStore" "', argument " "1"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStamp * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MemoryStore *)new FIX::MemoryStore((FIX::UtcTimeStamp const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MemoryStore, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  FIX::SEQNUM arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MemoryStore_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MemoryStore_set" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "MemoryStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  FIX::SEQNUM arg2 ;
  FIX::SEQNUM arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MemoryStore_get", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MemoryStore_get" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryStore_get" "', argument " "3"" of type '" "FIX::SEQNUM""'");
  } 
  arg3 = static_cast< FIX::SEQNUM >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MemoryStore_get" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MemoryStore_get" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            ((FIX::MemoryStore const *)arg1)->get(arg2,arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_getNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)((FIX::MemoryStore const *)arg1)->getNextSenderMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_getNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)((FIX::MemoryStore const *)arg1)->getNextTargetMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_setNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MemoryStore_setNextSenderMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MemoryStore_setNextSenderMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextSenderMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_setNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MemoryStore_setNextTargetMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MemoryStore_setNextTargetMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextTargetMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_incrNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->incrNextSenderMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_incrNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->incrNextTargetMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_setCreationTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MemoryStore_setCreationTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryStore_setCreationTime" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MemoryStore_setCreationTime" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setCreationTime((FIX::UtcTimeStamp const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_getCreationTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::UtcTimeStamp result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::MemoryStore const *)arg1)->getCreationTime();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::UtcTimeStamp(result)), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MemoryStore_reset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryStore_reset" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MemoryStore_reset" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->reset((FIX::UtcTimeStamp const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_refresh(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->refresh();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MemoryStore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MemoryStore_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MemoryStore, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MemoryStore_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MessageStoreFactoryExceptionWrapper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreFactory *arg1 = (FIX::MessageStoreFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::MessageStoreFactoryExceptionWrapper *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MessageStoreFactoryExceptionWrapper *)new FIX::MessageStoreFactoryExceptionWrapper(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStoreFactoryExceptionWrapper, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreFactoryExceptionWrapper_create(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreFactoryExceptionWrapper *arg1 = (FIX::MessageStoreFactoryExceptionWrapper *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  FIX::SessionID *arg3 = 0 ;
  bool *arg4 = 0 ;
  FIX::ConfigError *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  FIX::MessageStore *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreFactoryExceptionWrapper_create", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "4"" of type '" "bool &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "4"" of type '" "bool &""'"); 
  }
  arg4 = reinterpret_cast< bool * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FIX__ConfigError,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "5"" of type '" "FIX::ConfigError &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "5"" of type '" "FIX::ConfigError &""'"); 
  }
  arg5 = reinterpret_cast< FIX::ConfigError * >(argp5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MessageStore *)(arg1)->create((FIX::UtcTimeStamp const &)*arg2,(FIX::SessionID const &)*arg3,*arg4,*arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreFactoryExceptionWrapper_destroy(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreFactoryExceptionWrapper_destroy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->destroy(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MessageStoreFactoryExceptionWrapper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreFactoryExceptionWrapper *arg1 = (FIX::MessageStoreFactoryExceptionWrapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MessageStoreFactoryExceptionWrapper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MessageStoreFactoryExceptionWrapper, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MessageStoreFactoryExceptionWrapper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MessageStoreExceptionWrapper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::MessageStoreExceptionWrapper *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MessageStoreExceptionWrapper *)new FIX::MessageStoreExceptionWrapper(arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MessageStoreExceptionWrapper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  FIX::SEQNUM arg2 ;
  std::string *arg3 = 0 ;
  bool *arg4 = 0 ;
  FIX::IOException *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreExceptionWrapper_set", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStoreExceptionWrapper_set" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_set" "', argument " "4"" of type '" "bool &""'"); 
  }
  arg4 = reinterpret_cast< bool * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_set" "', argument " "5"" of type '" "FIX::IOException &""'"); 
  }
  arg5 = reinterpret_cast< FIX::IOException * >(argp5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->set(arg2,(std::string const &)*arg3,*arg4,*arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  FIX::SEQNUM arg2 ;
  FIX::SEQNUM arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  bool *arg5 = 0 ;
  FIX::IOException *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreExceptionWrapper_get", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStoreExceptionWrapper_get" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageStoreExceptionWrapper_get" "', argument " "3"" of type '" "FIX::SEQNUM""'");
  } 
  arg3 = static_cast< FIX::SEQNUM >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageStoreExceptionWrapper_get" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_get" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_get" "', argument " "5"" of type '" "bool &""'"); 
  }
  arg5 = reinterpret_cast< bool * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_get" "', argument " "6"" of type '" "FIX::IOException &""'"); 
  }
  arg6 = reinterpret_cast< FIX::IOException * >(argp6);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            ((FIX::MessageStoreExceptionWrapper const *)arg1)->get(arg2,arg3,*arg4,*arg5,*arg6);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_getNextSenderMsgSeqNum(PyObject *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 *swig_obj[3] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreExceptionWrapper_getNextSenderMsgSeqNum", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_getNextSenderMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_getNextSenderMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)((FIX::MessageStoreExceptionWrapper const *)arg1)->getNextSenderMsgSeqNum(*arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_getNextTargetMsgSeqNum(PyObject *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 *swig_obj[3] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreExceptionWrapper_getNextTargetMsgSeqNum", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_getNextTargetMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_getNextTargetMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)((FIX::MessageStoreExceptionWrapper const *)arg1)->getNextTargetMsgSeqNum(*arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_setNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  FIX::SEQNUM arg2 ;
  bool *arg3 = 0 ;
  FIX::IOException *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreExceptionWrapper_setNextSenderMsgSeqNum", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStoreExceptionWrapper_setNextSenderMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_setNextSenderMsgSeqNum" "', argument " "3"" of type '" "bool &""'"); 
  }
  arg3 = reinterpret_cast< bool * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_setNextSenderMsgSeqNum" "', argument " "4"" of type '" "FIX::IOException &""'"); 
  }
  arg4 = reinterpret_cast< FIX::IOException * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextSenderMsgSeqNum(arg2,*arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_setNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  FIX::SEQNUM arg2 ;
  bool *arg3 = 0 ;
  FIX::IOException *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreExceptionWrapper_setNextTargetMsgSeqNum", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStoreExceptionWrapper_setNextTargetMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_setNextTargetMsgSeqNum" "', argument " "3"" of type '" "bool &""'"); 
  }
  arg3 = reinterpret_cast< bool * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_setNextTargetMsgSeqNum" "', argument " "4"" of type '" "FIX::IOException &""'"); 
  }
  arg4 = reinterpret_cast< FIX::IOException * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextTargetMsgSeqNum(arg2,*arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->incrNextSenderMsgSeqNum(*arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->incrNextTargetMsgSeqNum(*arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_getCreationTime(PyObject *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 *swig_obj[3] ;
  FIX::UtcTimeStamp result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreExceptionWrapper_getCreationTime", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_getCreationTime" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_getCreationTime" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (arg1)->getCreationTime(*arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::UtcTimeStamp(result)), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  bool *arg3 = 0 ;
  FIX::IOException *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreExceptionWrapper_reset", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStoreExceptionWrapper_reset" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_reset" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MessageStoreExceptionWrapper_reset" "', argument " "3"" of type '" "bool &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_reset" "', argument " "3"" of type '" "bool &""'"); 
  }
  arg3 = reinterpret_cast< bool * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageStoreExceptionWrapper_reset" "', argument " "4"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_reset" "', argument " "4"" of type '" "FIX::IOException &""'"); 
  }
  arg4 = reinterpret_cast< FIX::IOException * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->reset((FIX::UtcTimeStamp const &)*arg2,*arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_refresh(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MessageStoreExceptionWrapper_refresh", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_refresh" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_refresh" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->refresh(*arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MessageStoreExceptionWrapper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MessageStoreExceptionWrapper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FileStoreFactory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::FileStoreFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_FileStoreFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FileStoreFactory *)new FIX::FileStoreFactory((FIX::SessionSettings const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FileStoreFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileStoreFactory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::FileStoreFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_FileStoreFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FileStoreFactory *)new FIX::FileStoreFactory((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileStoreFactory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FileStoreFactory", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileStoreFactory__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileStoreFactory__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FileStoreFactory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FileStoreFactory::FileStoreFactory(FIX::SessionSettings const &)\n"
    "    FIX::FileStoreFactory::FileStoreFactory(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FileStoreFactory_create(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStoreFactory *arg1 = (FIX::FileStoreFactory *) 0 ;
  FIX::UtcTimeStamp *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 *swig_obj[3] ;
  FIX::MessageStore *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileStoreFactory_create", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileStoreFactory_create" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "FileStoreFactory_create" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FileStoreFactory_create" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "FileStoreFactory_create" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MessageStore *)(arg1)->create((FIX::UtcTimeStamp const &)*arg2,(FIX::SessionID const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStoreFactory_destroy(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileStoreFactory_destroy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->destroy(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FileStoreFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStoreFactory *arg1 = (FIX::FileStoreFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FileStoreFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FileStoreFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FileStoreFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FileStore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStamp *arg1 = 0 ;
  std::string arg2 ;
  FIX::SessionID *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  FIX::FileStore *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_FileStore", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileStore" "', argument " "1"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FileStore" "', argument " "1"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStamp * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FileStore" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FileStore" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_FileStore" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::FileStore *)new FIX::FileStore((FIX::UtcTimeStamp const &)*arg1,SWIG_STD_MOVE(arg2),(FIX::SessionID const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FileStore, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FileStore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  FIX::SEQNUM arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileStore_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileStore_set" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "FileStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  FIX::SEQNUM arg2 ;
  FIX::SEQNUM arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileStore_get", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileStore_get" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileStore_get" "', argument " "3"" of type '" "FIX::SEQNUM""'");
  } 
  arg3 = static_cast< FIX::SEQNUM >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FileStore_get" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "FileStore_get" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            ((FIX::FileStore const *)arg1)->get(arg2,arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_getNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)((FIX::FileStore const *)arg1)->getNextSenderMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_getNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)((FIX::FileStore const *)arg1)->getNextTargetMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_setNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileStore_setNextSenderMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileStore_setNextSenderMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextSenderMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_setNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileStore_setNextTargetMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileStore_setNextTargetMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextTargetMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_incrNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->incrNextSenderMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_incrNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->incrNextTargetMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_getCreationTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::UtcTimeStamp result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::FileStore const *)arg1)->getCreationTime();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::UtcTimeStamp(result)), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileStore_reset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileStore_reset" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "FileStore_reset" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->reset((FIX::UtcTimeStamp const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_refresh(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->refresh();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FileStore_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FileStore, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FileStore_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_Application(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Application_onCreate(PyObject *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 *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Application_onCreate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "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()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::Application::onCreate");
            } else {
          (arg1)->onCreate((FIX::SessionID const &)*arg2);
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Application_onLogon(PyObject *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 *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Application_onLogon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "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()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::Application::onLogon");
            } else {
          (arg1)->onLogon((FIX::SessionID const &)*arg2);
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Application_onLogout(PyObject *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 *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Application_onLogout", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "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()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::Application::onLogout");
            } else {
          (arg1)->onLogout((FIX::SessionID const &)*arg2);
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Application_toAdmin(PyObject *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 *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Application_toAdmin", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Application_toAdmin" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "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()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::Application::toAdmin");
            } else {
          (arg1)->toAdmin(*arg2,(FIX::SessionID const &)*arg3);
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Application_toApp(PyObject *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 *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Application_toApp", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Application_toApp" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "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()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::Application::toApp");
            } else {
          (arg1)->toApp(*arg2,(FIX::SessionID const &)*arg3);
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Application_fromAdmin(PyObject *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 *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Application_fromAdmin", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Application_fromAdmin" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "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()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::Application::fromAdmin");
            } else {
          (arg1)->fromAdmin((FIX::Message const &)*arg2,(FIX::SessionID const &)*arg3);
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Application_fromApp(PyObject *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 *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Application_fromApp", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Application_fromApp" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "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()==swig_obj[0]));
  try {
    {
      if(!tryPythonException([&]() mutable
          {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("FIX::Application::fromApp");
            } else {
          (arg1)->fromApp((FIX::Message const &)*arg2,(FIX::SessionID const &)*arg3);
            }
            return true;
          fail:
            return false;
          }))
      {
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Application(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  FIX::Application *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    if(!tryPythonException([&]() mutable
        {
      {
        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;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Application, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Application(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Application" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Application_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Application, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Application_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SynchronizedApplication(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SynchronizedApplication *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_SynchronizedApplication" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SynchronizedApplication *)new FIX::SynchronizedApplication(*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SynchronizedApplication, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_onCreate(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SynchronizedApplication_onCreate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "SynchronizedApplication_onCreate" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onCreate((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_onLogon(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SynchronizedApplication_onLogon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "SynchronizedApplication_onLogon" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onLogon((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_onLogout(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SynchronizedApplication_onLogout", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "SynchronizedApplication_onLogout" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onLogout((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_toAdmin(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SynchronizedApplication_toAdmin", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "SynchronizedApplication_toAdmin" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "SynchronizedApplication_toAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->toAdmin(*arg2,(FIX::SessionID const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_toApp(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SynchronizedApplication_toApp", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "SynchronizedApplication_toApp" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "SynchronizedApplication_toApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->toApp(*arg2,(FIX::SessionID const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_fromAdmin(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SynchronizedApplication_fromAdmin", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "SynchronizedApplication_fromAdmin" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "SynchronizedApplication_fromAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->fromAdmin((FIX::Message const &)*arg2,(FIX::SessionID const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_fromApp(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SynchronizedApplication_fromApp", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "SynchronizedApplication_fromApp" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "SynchronizedApplication_fromApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->fromApp((FIX::Message const &)*arg2,(FIX::SessionID const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_m_mutex_set(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SynchronizedApplication_m_mutex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "SynchronizedApplication_m_mutex_set" "', argument " "2"" of type '" "Mutex""'");
    } else {
      Mutex * temp = reinterpret_cast< Mutex * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->m_mutex = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_m_mutex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Mutex result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(result)), SWIGTYPE_p_Mutex, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_app(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  FIX::Application *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Application *) &(arg1)->app();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Application, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_m_app_set(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SynchronizedApplication_m_app_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "SynchronizedApplication_m_app_set" "', argument " "2"" of type '" "FIX::Application &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Application * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->m_app = *arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_m_app_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  FIX::Application *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SynchronizedApplication_m_app_get" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Application *) &(FIX::Application &) ((arg1)->m_app);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Application, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SynchronizedApplication(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SynchronizedApplication_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SynchronizedApplication, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SynchronizedApplication_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NullApplication(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullApplication *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_NullApplication", 0, 0, 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::NullApplication *)new FIX::NullApplication();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NullApplication, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NullApplication(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullApplication *arg1 = (FIX::NullApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NullApplication_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NullApplication, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NullApplication_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_Initiator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_start(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->start();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_block(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->block();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_poll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->poll();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_stop__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->stop(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_stop__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->stop();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_stop(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Initiator_stop", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Initiator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Initiator_stop__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Initiator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Initiator_stop__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Initiator_stop'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Initiator::stop(bool)\n"
    "    FIX::Initiator::stop()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Initiator_isLoggedOn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_isLoggedOn" "', argument " "1"" of type '" "FIX::Initiator const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Initiator const *)arg1)->isLoggedOn();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getSession__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  Responder *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::Session *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Initiator_getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "Initiator_getSession" "', argument " "3"" of type '" "Responder &""'"); 
  }
  arg3 = reinterpret_cast< Responder * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Session *)(arg1)->getSession((FIX::SessionID const &)*arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getSessions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *) &((FIX::Initiator const *)arg1)->getSessions();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getSession__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FIX::Session *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Initiator_getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Session *)((FIX::Initiator const *)arg1)->getSession((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getSession(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Initiator_getSession", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Initiator_getSession__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Responder, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Initiator_getSession__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Initiator_getSession'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Initiator::getSession(FIX::SessionID const &,Responder &)\n"
    "    FIX::Initiator::getSession(FIX::SessionID const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Initiator_getSessionSettings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  FIX::Dictionary *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Initiator_getSessionSettings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Initiator_getSessionSettings" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Dictionary *)((FIX::Initiator const *)arg1)->getSessionSettings((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_has(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Initiator_has", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Initiator_has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Initiator const *)arg1)->has((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_isStopped(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_isStopped" "', argument " "1"" of type '" "FIX::Initiator const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Initiator const *)arg1)->isStopped();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getApplication(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  FIX::Application *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Application *) &((FIX::Initiator const *)arg1)->getApplication();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Application, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getMessageStoreFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::MessageStoreFactory *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MessageStoreFactory *) &((FIX::Initiator const *)arg1)->getMessageStoreFactory();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  FIX::Log *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Log *)(arg1)->getLog();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Initiator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Initiator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SocketInitiatorBase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::SocketInitiator *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketInitiatorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketInitiatorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketInitiatorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SocketInitiator *)new FIX::SocketInitiator(*arg1,*arg2,(FIX::SessionSettings const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketInitiator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketInitiatorBase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *arg3 = 0 ;
  FIX::LogFactory *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FIX::SocketInitiator *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketInitiatorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketInitiatorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketInitiatorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketInitiatorBase" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  arg4 = reinterpret_cast< FIX::LogFactory * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SocketInitiator *)new FIX::SocketInitiator(*arg1,*arg2,(FIX::SessionSettings const &)*arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketInitiator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketInitiatorBase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SocketInitiatorBase", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SocketInitiatorBase__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__LogFactory, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SocketInitiatorBase__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SocketInitiatorBase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SocketInitiator::SocketInitiator(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &)\n"
    "    FIX::SocketInitiator::SocketInitiator(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &,FIX::LogFactory &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SocketInitiatorBase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketInitiator *arg1 = (FIX::SocketInitiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SocketInitiatorBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SocketInitiator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SocketInitiatorBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_Acceptor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  FIX::Log *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Log *)(arg1)->getLog();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_start(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->start();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_block(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->block();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_poll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->poll();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_stop__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->stop(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_stop__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->stop();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_stop(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Acceptor_stop", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Acceptor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Acceptor_stop__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Acceptor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Acceptor_stop__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Acceptor_stop'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Acceptor::stop(bool)\n"
    "    FIX::Acceptor::stop()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Acceptor_isLoggedOn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_isLoggedOn" "', argument " "1"" of type '" "FIX::Acceptor const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Acceptor const *)arg1)->isLoggedOn();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getSession__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  std::string *arg2 = 0 ;
  Responder *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::Session *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Acceptor_getSession" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "Acceptor_getSession" "', argument " "3"" of type '" "Responder &""'"); 
  }
  arg3 = reinterpret_cast< Responder * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Session *)(arg1)->getSession((std::string const &)*arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getSessions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *) &((FIX::Acceptor const *)arg1)->getSessions();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getSession__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FIX::Session *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Acceptor_getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Session *)((FIX::Acceptor const *)arg1)->getSession((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getSession(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Acceptor_getSession", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Acceptor_getSession__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Acceptor_getSession__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Acceptor_getSession'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Acceptor::getSession(std::string const &,Responder &)\n"
    "    FIX::Acceptor::getSession(FIX::SessionID const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Acceptor_getSessionSettings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  FIX::Dictionary *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Acceptor_getSessionSettings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Acceptor_getSessionSettings" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Dictionary *)((FIX::Acceptor const *)arg1)->getSessionSettings((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_has(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Acceptor_has", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "Acceptor_has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Acceptor const *)arg1)->has((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_isStopped(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_isStopped" "', argument " "1"" of type '" "FIX::Acceptor const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::Acceptor const *)arg1)->isStopped();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getApplication(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  FIX::Application *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Application *) &((FIX::Acceptor const *)arg1)->getApplication();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Application, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getMessageStoreFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::MessageStoreFactory *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MessageStoreFactory *) &((FIX::Acceptor const *)arg1)->getMessageStoreFactory();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Acceptor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Acceptor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SocketAcceptorBase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::SocketAcceptor *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketAcceptorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketAcceptorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketAcceptorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SocketAcceptor *)new FIX::SocketAcceptor(*arg1,*arg2,(FIX::SessionSettings const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketAcceptor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketAcceptorBase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *arg3 = 0 ;
  FIX::LogFactory *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FIX::SocketAcceptor *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketAcceptorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketAcceptorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketAcceptorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &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_NullReferenceError, "invalid null reference " "in method '" "new_SocketAcceptorBase" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  arg4 = reinterpret_cast< FIX::LogFactory * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SocketAcceptor *)new FIX::SocketAcceptor(*arg1,*arg2,(FIX::SessionSettings const &)*arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketAcceptor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketAcceptorBase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SocketAcceptorBase", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SocketAcceptorBase__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__LogFactory, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SocketAcceptorBase__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SocketAcceptorBase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SocketAcceptor::SocketAcceptor(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &)\n"
    "    FIX::SocketAcceptor::SocketAcceptor(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &,FIX::LogFactory &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SocketAcceptorBase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketAcceptor *arg1 = (FIX::SocketAcceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SocketAcceptorBase_sessionToPort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketAcceptor *arg1 = (FIX::SocketAcceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SocketAcceptor::SessionToPort *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__SocketAcceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SocketAcceptorBase_sessionToPort" "', argument " "1"" of type '" "FIX::SocketAcceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SocketAcceptor * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SocketAcceptor::SessionToPort *) &(arg1)->sessionToPort();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_FIX__SessionID_unsigned_short_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SocketAcceptorBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SocketAcceptor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SocketAcceptorBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DataDictionary__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DataDictionary *)new FIX::DataDictionary();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionary__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::DataDictionary *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_DataDictionary" "', argument " "1"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DataDictionary *)new FIX::DataDictionary((FIX::DataDictionary const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionary__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  FIX::DataDictionary *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_DataDictionary" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DataDictionary" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DataDictionary *)new FIX::DataDictionary(*arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionary__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::DataDictionary *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_DataDictionary" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DataDictionary *)new FIX::DataDictionary(*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionary__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  FIX::DataDictionary *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_DataDictionary" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DataDictionary" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DataDictionary *)new FIX::DataDictionary((std::string const &)*arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionary__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::DataDictionary *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "new_DataDictionary" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DataDictionary *)new FIX::DataDictionary((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionary(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DataDictionary", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DataDictionary__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DataDictionary__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DataDictionary__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DataDictionary__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DataDictionary__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DataDictionary__SWIG_4(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DataDictionary'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DataDictionary::DataDictionary()\n"
    "    FIX::DataDictionary::DataDictionary(FIX::DataDictionary const &)\n"
    "    FIX::DataDictionary::DataDictionary(std::istream &,bool)\n"
    "    FIX::DataDictionary::DataDictionary(std::istream &)\n"
    "    FIX::DataDictionary::DataDictionary(std::string const &,bool)\n"
    "    FIX::DataDictionary::DataDictionary(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DataDictionary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_readFromURL(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_readFromURL", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_readFromURL" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->readFromURL((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_readFromDocument(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  DOMDocumentPtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_readFromDocument", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_readFromDocument" "', argument " "2"" of type '" "DOMDocumentPtr const &""'"); 
  }
  arg2 = reinterpret_cast< DOMDocumentPtr * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->readFromDocument((DOMDocumentPtr const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_readFromStream(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_readFromStream", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_readFromStream" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->readFromStream(*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getOrderedFields(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  message_order *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (message_order *) &((FIX::DataDictionary const *)arg1)->getOrderedFields();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_message_order, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getHeaderOrderedFields(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  message_order *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_getHeaderOrderedFields" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (message_order *) &((FIX::DataDictionary const *)arg1)->getHeaderOrderedFields();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_message_order, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getTrailerOrderedFields(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  message_order *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_getTrailerOrderedFields" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (message_order *) &((FIX::DataDictionary const *)arg1)->getTrailerOrderedFields();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_message_order, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getMessageOrderedFields(PyObject *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 *swig_obj[2] ;
  message_order *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_getMessageOrderedFields", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_getMessageOrderedFields" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataDictionary_getMessageOrderedFields" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_getMessageOrderedFields" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (message_order *) &((FIX::DataDictionary const *)arg1)->getMessageOrderedFields((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_message_order, 0 |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_setVersion(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_setVersion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_setVersion" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setVersion((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getVersion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::DataDictionary const *)arg1)->getVersion();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addField(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_addField", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addField(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addFieldName(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_addFieldName", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_addFieldName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addFieldName(arg2,(std::string const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getFieldName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string temp3 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_getFieldName", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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*)PyUnicode_AsUTF8(swig_obj[2]));
    arg3 = &temp3;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->getFieldName(arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  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, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getFieldTag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int temp3 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_getFieldTag", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataDictionary_getFieldTag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_getFieldTag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_AsVal_int(swig_obj[2], &temp3);
    arg3 = &temp3;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->getFieldTag((std::string const &)*arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("int &") == "int &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyLong_FromLong(*arg3) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addValueName(PyObject *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 *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_addValueName", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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_NullReferenceError, "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(swig_obj[3], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_addValueName" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addValueName(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getValueName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  std::string temp4 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_getValueName", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_getValueName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    temp4 = std::string((char*)PyUnicode_AsUTF8(swig_obj[3]));
    arg4 = &temp4;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->getValueName(arg2,(std::string const &)*arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getNameValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  std::string temp4 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_getNameValue", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_getNameValue" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_getNameValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DataDictionary_getNameValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_getNameValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    temp4 = std::string((char*)PyUnicode_AsUTF8(swig_obj[3]));
    arg4 = &temp4;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->getNameValue(arg2,(std::string const &)*arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isField(PyObject *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 *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_isField", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->isField(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addMsgType(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_addMsgType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_addMsgType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addMsgType((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isMsgType(PyObject *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 *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_isMsgType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_isMsgType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->isMsgType((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addMsgField(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_addMsgField", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_addMsgField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addMsgField((std::string const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isMsgField(PyObject *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 *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_isMsgField", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_isMsgField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->isMsgField((std::string const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addHeaderField(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_addHeaderField", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addHeaderField(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isHeaderField(PyObject *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 *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_isHeaderField", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->isHeaderField(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addTrailerField(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_addTrailerField", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addTrailerField(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isTrailerField(PyObject *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 *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_isTrailerField", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->isTrailerField(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addFieldType(PyObject *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 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_addFieldType", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataDictionary_addFieldType" "', argument " "3"" of type '" "FIX::TYPE::Type""'");
  } 
  arg3 = static_cast< FIX::TYPE::Type >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addFieldType(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getFieldType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  FIX::TYPE::Type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_getFieldType", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_getFieldType" "', argument " "3"" of type '" "FIX::TYPE::Type &""'"); 
  }
  arg3 = reinterpret_cast< FIX::TYPE::Type * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->getFieldType(arg2,*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addRequiredField(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_addRequiredField", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_addRequiredField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addRequiredField((std::string const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isRequiredField(PyObject *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 *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_isRequiredField", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_isRequiredField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->isRequiredField((std::string const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addFieldValue(PyObject *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 *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_addFieldValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_addFieldValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addFieldValue(arg2,(std::string const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_hasFieldValue(PyObject *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 *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_hasFieldValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->hasFieldValue(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isFieldValue(PyObject *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 *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_isFieldValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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(swig_obj[2], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_isFieldValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->isFieldValue(arg2,(std::string const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addGroup(PyObject *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 *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_addGroup", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_addGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_addGroup" "', argument " "5"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg5 = reinterpret_cast< FIX::DataDictionary * >(argp5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->addGroup((std::string const &)*arg2,arg3,arg4,(FIX::DataDictionary const &)*arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isGroup(PyObject *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 *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_isGroup", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_isGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->isGroup((std::string const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getGroup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  int *arg4 = 0 ;
  FIX::DataDictionary **arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  int temp4 ;
  FIX::DataDictionary *temp5 ;
  PyObject *swig_obj[5] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_getGroup", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_getGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &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(swig_obj[3], &temp4);
    arg4 = &temp4;
  }
  {
    arg5 = new FIX::DataDictionary*[1];
    *arg5 = temp5;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        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;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("int &") == "int &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyLong_FromLong(*arg4) );
    }
  }
  {
    void* argp;
    FIX::DataDictionary* pDD = 0;
    int res = SWIG_ConvertPtr(swig_obj[4], &argp, SWIGTYPE_p_FIX__DataDictionary, 0 );
    pDD = reinterpret_cast<FIX::DataDictionary *>(argp);
    *pDD = *(*arg5);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isDataField(PyObject *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 *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_isDataField", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->isDataField(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isMultipleValueField(PyObject *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 *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_isMultipleValueField", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->isMultipleValueField(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_checkFieldsOutOfOrder(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_checkFieldsOutOfOrder", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->checkFieldsOutOfOrder(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_checkFieldsHaveValues(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_checkFieldsHaveValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->checkFieldsHaveValues(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_checkUserDefinedFields(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_checkUserDefinedFields", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->checkUserDefinedFields(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_allowUnknownMsgFields(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_allowUnknownMsgFields", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_allowUnknownMsgFields" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_allowUnknownMsgFields" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->allowUnknownMsgFields(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_preserveMessageFieldsOrder(PyObject *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 *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DataDictionary_preserveMessageFieldsOrder", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_preserveMessageFieldsOrder" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_preserveMessageFieldsOrder" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->preserveMessageFieldsOrder(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isMessageFieldsOrderPreserved(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_isMessageFieldsOrderPreserved" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)((FIX::DataDictionary const *)arg1)->isMessageFieldsOrderPreserved();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_validate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_validate" "', argument " "1"" of type '" "FIX::Message const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            FIX::DataDictionary::validate((FIX::Message const &)*arg1,(FIX::DataDictionary const *)arg2,(FIX::DataDictionary const *)arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_validate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_validate" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            ((FIX::DataDictionary const *)arg1)->validate((FIX::Message const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_validate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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_NullReferenceError, "invalid null reference " "in method '" "DataDictionary_validate" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &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);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            ((FIX::DataDictionary const *)arg1)->validate((FIX::Message const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_validate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DataDictionary_validate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DataDictionary_validate__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__Message, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DataDictionary_validate__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DataDictionary_validate__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DataDictionary_validate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DataDictionary::validate(FIX::Message const &,FIX::DataDictionary const *const,FIX::DataDictionary const *const)\n"
    "    FIX::DataDictionary::validate(FIX::Message const &) const\n"
    "    FIX::DataDictionary::validate(FIX::Message const &,bool) const\n");
  return 0;
}


SWIGINTERN PyObject *DataDictionary_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DataDictionary, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DataDictionary_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SSLSocketAcceptorBase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::SSLSocketAcceptor *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SSLSocketAcceptorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SSLSocketAcceptorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SSLSocketAcceptorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SSLSocketAcceptorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SSLSocketAcceptorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SSLSocketAcceptorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SSLSocketAcceptor *)new FIX::SSLSocketAcceptor(*arg1,*arg2,(FIX::SessionSettings const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SSLSocketAcceptor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SSLSocketAcceptorBase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *arg3 = 0 ;
  FIX::LogFactory *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FIX::SSLSocketAcceptor *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SSLSocketAcceptorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SSLSocketAcceptorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SSLSocketAcceptorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SSLSocketAcceptorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SSLSocketAcceptorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SSLSocketAcceptorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FIX__LogFactory,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SSLSocketAcceptorBase" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SSLSocketAcceptorBase" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  arg4 = reinterpret_cast< FIX::LogFactory * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SSLSocketAcceptor *)new FIX::SSLSocketAcceptor(*arg1,*arg2,(FIX::SessionSettings const &)*arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SSLSocketAcceptor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SSLSocketAcceptorBase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SSLSocketAcceptorBase", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SSLSocketAcceptorBase__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__LogFactory, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SSLSocketAcceptorBase__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SSLSocketAcceptorBase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SSLSocketAcceptor::SSLSocketAcceptor(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &)\n"
    "    FIX::SSLSocketAcceptor::SSLSocketAcceptor(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &,FIX::LogFactory &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SSLSocketAcceptorBase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SSLSocketAcceptor *arg1 = (FIX::SSLSocketAcceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__SSLSocketAcceptor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SSLSocketAcceptorBase" "', argument " "1"" of type '" "FIX::SSLSocketAcceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SSLSocketAcceptor * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SSLSocketAcceptorBase_setPassword(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SSLSocketAcceptor *arg1 = (FIX::SSLSocketAcceptor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SSLSocketAcceptorBase_setPassword", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__SSLSocketAcceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SSLSocketAcceptorBase_setPassword" "', argument " "1"" of type '" "FIX::SSLSocketAcceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SSLSocketAcceptor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SSLSocketAcceptorBase_setPassword" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SSLSocketAcceptorBase_setPassword" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setPassword((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SSLSocketAcceptorBase_passwordHandleCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SSLSocketAcceptor *arg1 = (FIX::SSLSocketAcceptor *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SSLSocketAcceptorBase_passwordHandleCallback", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__SSLSocketAcceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SSLSocketAcceptorBase_passwordHandleCallback" "', argument " "1"" of type '" "FIX::SSLSocketAcceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SSLSocketAcceptor * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SSLSocketAcceptorBase_passwordHandleCallback" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SSLSocketAcceptorBase_passwordHandleCallback" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SSLSocketAcceptorBase_passwordHandleCallback" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)(arg1)->passwordHandleCallback(arg2,SWIG_STD_MOVE(arg3),arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SSLSocketAcceptorBase_passPhraseHandleCB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  void *arg4 = (void *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SSLSocketAcceptorBase_passPhraseHandleCB", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SSLSocketAcceptorBase_passPhraseHandleCB" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SSLSocketAcceptorBase_passPhraseHandleCB" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SSLSocketAcceptorBase_passPhraseHandleCB" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SSLSocketAcceptorBase_passPhraseHandleCB" "', argument " "4"" of type '" "void *""'"); 
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)FIX::SSLSocketAcceptor::passPhraseHandleCB(arg1,arg2,arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *SSLSocketAcceptorBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SSLSocketAcceptor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SSLSocketAcceptorBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SSLSocketInitiatorBase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::SSLSocketInitiator *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SSLSocketInitiatorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SSLSocketInitiatorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SSLSocketInitiatorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SSLSocketInitiatorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SSLSocketInitiatorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SSLSocketInitiatorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SSLSocketInitiator *)new FIX::SSLSocketInitiator(*arg1,*arg2,(FIX::SessionSettings const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SSLSocketInitiator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SSLSocketInitiatorBase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *arg3 = 0 ;
  FIX::LogFactory *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FIX::SSLSocketInitiator *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SSLSocketInitiatorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SSLSocketInitiatorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SSLSocketInitiatorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SSLSocketInitiatorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SSLSocketInitiatorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SSLSocketInitiatorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FIX__LogFactory,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SSLSocketInitiatorBase" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SSLSocketInitiatorBase" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  arg4 = reinterpret_cast< FIX::LogFactory * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SSLSocketInitiator *)new FIX::SSLSocketInitiator(*arg1,*arg2,(FIX::SessionSettings const &)*arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SSLSocketInitiator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SSLSocketInitiatorBase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SSLSocketInitiatorBase", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SSLSocketInitiatorBase__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__LogFactory, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SSLSocketInitiatorBase__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SSLSocketInitiatorBase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SSLSocketInitiator::SSLSocketInitiator(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &)\n"
    "    FIX::SSLSocketInitiator::SSLSocketInitiator(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &,FIX::LogFactory &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SSLSocketInitiatorBase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SSLSocketInitiator *arg1 = (FIX::SSLSocketInitiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__SSLSocketInitiator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SSLSocketInitiatorBase" "', argument " "1"" of type '" "FIX::SSLSocketInitiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SSLSocketInitiator * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SSLSocketInitiatorBase_setPassword(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SSLSocketInitiator *arg1 = (FIX::SSLSocketInitiator *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SSLSocketInitiatorBase_setPassword", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__SSLSocketInitiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SSLSocketInitiatorBase_setPassword" "', argument " "1"" of type '" "FIX::SSLSocketInitiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SSLSocketInitiator * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SSLSocketInitiatorBase_setPassword" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SSLSocketInitiatorBase_setPassword" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setPassword((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SSLSocketInitiatorBase_setCertAndKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SSLSocketInitiator *arg1 = (FIX::SSLSocketInitiator *) 0 ;
  X509 *arg2 = (X509 *) 0 ;
  RSA *arg3 = (RSA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SSLSocketInitiatorBase_setCertAndKey", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__SSLSocketInitiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SSLSocketInitiatorBase_setCertAndKey" "', argument " "1"" of type '" "FIX::SSLSocketInitiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SSLSocketInitiator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_X509, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SSLSocketInitiatorBase_setCertAndKey" "', argument " "2"" of type '" "X509 *""'"); 
  }
  arg2 = reinterpret_cast< X509 * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_RSA, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SSLSocketInitiatorBase_setCertAndKey" "', argument " "3"" of type '" "RSA *""'"); 
  }
  arg3 = reinterpret_cast< RSA * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setCertAndKey(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SSLSocketInitiatorBase_passwordHandleCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SSLSocketInitiator *arg1 = (FIX::SSLSocketInitiator *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SSLSocketInitiatorBase_passwordHandleCallback", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__SSLSocketInitiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SSLSocketInitiatorBase_passwordHandleCallback" "', argument " "1"" of type '" "FIX::SSLSocketInitiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SSLSocketInitiator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SSLSocketInitiatorBase_passwordHandleCallback" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SSLSocketInitiatorBase_passwordHandleCallback" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SSLSocketInitiatorBase_passwordHandleCallback" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)(arg1)->passwordHandleCallback(arg2,SWIG_STD_MOVE(arg3),arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SSLSocketInitiatorBase_passwordHandleCB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  void *arg4 = (void *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SSLSocketInitiatorBase_passwordHandleCB", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SSLSocketInitiatorBase_passwordHandleCB" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SSLSocketInitiatorBase_passwordHandleCB" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SSLSocketInitiatorBase_passwordHandleCB" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SSLSocketInitiatorBase_passwordHandleCB" "', argument " "4"" of type '" "void *""'"); 
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)FIX::SSLSocketInitiator::passwordHandleCB(arg1,arg2,arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *SSLSocketInitiatorBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SSLSocketInitiator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SSLSocketInitiatorBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DatabaseConnectionID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  short arg5 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  short val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  FIX::DatabaseConnectionID *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_DatabaseConnectionID", 5, 5, swig_obj)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DatabaseConnectionID" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DatabaseConnectionID" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DatabaseConnectionID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DatabaseConnectionID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DatabaseConnectionID" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DatabaseConnectionID" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DatabaseConnectionID" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DatabaseConnectionID" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DatabaseConnectionID" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DatabaseConnectionID *)new FIX::DatabaseConnectionID((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DatabaseConnectionID *arg1 = 0 ;
  FIX::DatabaseConnectionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DatabaseConnectionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lt__" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__lt__" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__DatabaseConnectionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lt__" "', argument " "2"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__lt__" "', argument " "2"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator <((FIX::DatabaseConnectionID const &)*arg1,(FIX::DatabaseConnectionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lt__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__lt__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___eq____SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DatabaseConnectionID *arg1 = 0 ;
  FIX::DatabaseConnectionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DatabaseConnectionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__DatabaseConnectionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator ==((FIX::DatabaseConnectionID const &)*arg1,(FIX::DatabaseConnectionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___eq__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__eq__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DatabaseConnectionID *arg1 = 0 ;
  FIX::DatabaseConnectionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DatabaseConnectionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__DatabaseConnectionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)operator !=((FIX::DatabaseConnectionID const &)*arg1,(FIX::DatabaseConnectionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__ne__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DateTime, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ne____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ne____SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ne____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ne____SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ne____SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ne____SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ne____SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_DatabaseConnectionID_getDatabase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DatabaseConnectionID *arg1 = (FIX::DatabaseConnectionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DatabaseConnectionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatabaseConnectionID_getDatabase" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::DatabaseConnectionID const *)arg1)->getDatabase();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DatabaseConnectionID_getUser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DatabaseConnectionID *arg1 = (FIX::DatabaseConnectionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DatabaseConnectionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatabaseConnectionID_getUser" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::DatabaseConnectionID const *)arg1)->getUser();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DatabaseConnectionID_getPassword(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DatabaseConnectionID *arg1 = (FIX::DatabaseConnectionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DatabaseConnectionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatabaseConnectionID_getPassword" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::DatabaseConnectionID const *)arg1)->getPassword();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DatabaseConnectionID_getHost(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DatabaseConnectionID *arg1 = (FIX::DatabaseConnectionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DatabaseConnectionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatabaseConnectionID_getHost" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &((FIX::DatabaseConnectionID const *)arg1)->getHost();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DatabaseConnectionID_getPort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DatabaseConnectionID *arg1 = (FIX::DatabaseConnectionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DatabaseConnectionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatabaseConnectionID_getPort" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (short)((FIX::DatabaseConnectionID const *)arg1)->getPort();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DatabaseConnectionID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DatabaseConnectionID *arg1 = (FIX::DatabaseConnectionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DatabaseConnectionID" "', argument " "1"" of type '" "FIX::DatabaseConnectionID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DatabaseConnectionID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DatabaseConnectionID_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MySQLQuery(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  FIX::MySQLQuery *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MySQLQuery" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLQuery" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLQuery *)new FIX::MySQLQuery((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLQuery, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MySQLQuery(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLQuery *arg1 = (FIX::MySQLQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLQuery, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MySQLQuery" "', argument " "1"" of type '" "FIX::MySQLQuery *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLQuery * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLQuery_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLQuery *arg1 = (FIX::MySQLQuery *) 0 ;
  MYSQL *arg2 = (MYSQL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLQuery_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLQuery_execute" "', argument " "1"" of type '" "FIX::MySQLQuery *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLQuery * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_MYSQL, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MySQLQuery_execute" "', argument " "2"" of type '" "MYSQL *""'"); 
  }
  arg2 = reinterpret_cast< MYSQL * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->execute(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLQuery_success(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLQuery *arg1 = (FIX::MySQLQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLQuery_success" "', argument " "1"" of type '" "FIX::MySQLQuery *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLQuery * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->success();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLQuery_rows(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLQuery *arg1 = (FIX::MySQLQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLQuery_rows" "', argument " "1"" of type '" "FIX::MySQLQuery *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLQuery * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)(arg1)->rows();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLQuery_reason(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLQuery *arg1 = (FIX::MySQLQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLQuery_reason" "', argument " "1"" of type '" "FIX::MySQLQuery *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLQuery * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (std::string *) &(arg1)->reason();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLQuery_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLQuery *arg1 = (FIX::MySQLQuery *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLQuery_getValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLQuery_getValue" "', argument " "1"" of type '" "FIX::MySQLQuery *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLQuery * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MySQLQuery_getValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MySQLQuery_getValue" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (char *)(arg1)->getValue(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLQuery_throwException(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLQuery *arg1 = (FIX::MySQLQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLQuery_throwException" "', argument " "1"" of type '" "FIX::MySQLQuery *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLQuery * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->throwException();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MySQLQuery_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MySQLQuery, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MySQLQuery_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MySQLConnection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DatabaseConnectionID *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::MySQLConnection *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DatabaseConnectionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MySQLConnection" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLConnection" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLConnection *)new FIX::MySQLConnection((FIX::DatabaseConnectionID const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLConnection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLConnection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  short arg5 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  short val5 ;
  int ecode5 = 0 ;
  FIX::MySQLConnection *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MySQLConnection" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLConnection" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MySQLConnection" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLConnection" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MySQLConnection" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLConnection" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MySQLConnection" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLConnection" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MySQLConnection" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLConnection *)new FIX::MySQLConnection((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLConnection, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLConnection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MySQLConnection", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MySQLConnection__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v = 0;
    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) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_MySQLConnection__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MySQLConnection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MySQLConnection::MySQLConnection(FIX::DatabaseConnectionID const &)\n"
    "    FIX::MySQLConnection::MySQLConnection(std::string const &,std::string const &,std::string const &,std::string const &,short)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MySQLConnection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLConnection *arg1 = (FIX::MySQLConnection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLConnection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MySQLConnection" "', argument " "1"" of type '" "FIX::MySQLConnection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLConnection * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLConnection_connectionID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLConnection *arg1 = (FIX::MySQLConnection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::DatabaseConnectionID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLConnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLConnection_connectionID" "', argument " "1"" of type '" "FIX::MySQLConnection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLConnection * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DatabaseConnectionID *) &(arg1)->connectionID();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DatabaseConnectionID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLConnection_connected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLConnection *arg1 = (FIX::MySQLConnection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLConnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLConnection_connected" "', argument " "1"" of type '" "FIX::MySQLConnection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLConnection * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->connected();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLConnection_reconnect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLConnection *arg1 = (FIX::MySQLConnection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLConnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLConnection_reconnect" "', argument " "1"" of type '" "FIX::MySQLConnection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLConnection * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->reconnect();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLConnection_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLConnection *arg1 = (FIX::MySQLConnection *) 0 ;
  FIX::MySQLQuery *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLConnection_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLConnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLConnection_execute" "', argument " "1"" of type '" "FIX::MySQLConnection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLConnection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__MySQLQuery,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MySQLConnection_execute" "', argument " "2"" of type '" "FIX::MySQLQuery &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MySQLConnection_execute" "', argument " "2"" of type '" "FIX::MySQLQuery &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MySQLQuery * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->execute(*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MySQLConnection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MySQLConnection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MySQLConnection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_MySQLStoreFactory_DEFAULT_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MySQLStoreFactory_DEFAULT_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MySQLStoreFactory_DEFAULT_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::MySQLStoreFactory::DEFAULT_DATABASE));
  return pyobj;
}


SWIGINTERN int Swig_var_MySQLStoreFactory_DEFAULT_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MySQLStoreFactory_DEFAULT_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MySQLStoreFactory_DEFAULT_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::MySQLStoreFactory::DEFAULT_USER));
  return pyobj;
}


SWIGINTERN int Swig_var_MySQLStoreFactory_DEFAULT_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MySQLStoreFactory_DEFAULT_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MySQLStoreFactory_DEFAULT_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::MySQLStoreFactory::DEFAULT_PASSWORD));
  return pyobj;
}


SWIGINTERN int Swig_var_MySQLStoreFactory_DEFAULT_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MySQLStoreFactory_DEFAULT_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MySQLStoreFactory_DEFAULT_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::MySQLStoreFactory::DEFAULT_HOST));
  return pyobj;
}


SWIGINTERN int Swig_var_MySQLStoreFactory_DEFAULT_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MySQLStoreFactory_DEFAULT_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MySQLStoreFactory_DEFAULT_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_short(static_cast< short >(FIX::MySQLStoreFactory::DEFAULT_PORT));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_MySQLStoreFactory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::MySQLStoreFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MySQLStoreFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStoreFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLStoreFactory *)new FIX::MySQLStoreFactory((FIX::SessionSettings const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLStoreFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLStoreFactory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::MySQLStoreFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__Dictionary,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MySQLStoreFactory" "', argument " "1"" of type '" "FIX::Dictionary const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStoreFactory" "', argument " "1"" of type '" "FIX::Dictionary const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLStoreFactory *)new FIX::MySQLStoreFactory((FIX::Dictionary const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLStoreFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLStoreFactory__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  short arg5 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  short val5 ;
  int ecode5 = 0 ;
  FIX::MySQLStoreFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MySQLStoreFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStoreFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MySQLStoreFactory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStoreFactory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MySQLStoreFactory" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStoreFactory" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MySQLStoreFactory" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStoreFactory" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MySQLStoreFactory" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLStoreFactory *)new FIX::MySQLStoreFactory((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLStoreFactory, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLStoreFactory__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::MySQLStoreFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLStoreFactory *)new FIX::MySQLStoreFactory();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLStoreFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLStoreFactory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MySQLStoreFactory", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MySQLStoreFactory__SWIG_3(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__Dictionary, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MySQLStoreFactory__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MySQLStoreFactory__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v = 0;
    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) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_MySQLStoreFactory__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MySQLStoreFactory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MySQLStoreFactory::MySQLStoreFactory(FIX::SessionSettings const &)\n"
    "    FIX::MySQLStoreFactory::MySQLStoreFactory(FIX::Dictionary const &)\n"
    "    FIX::MySQLStoreFactory::MySQLStoreFactory(std::string const &,std::string const &,std::string const &,std::string const &,short)\n"
    "    FIX::MySQLStoreFactory::MySQLStoreFactory()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MySQLStoreFactory_create(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStoreFactory *arg1 = (FIX::MySQLStoreFactory *) 0 ;
  FIX::UtcTimeStamp *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 *swig_obj[3] ;
  FIX::MessageStore *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLStoreFactory_create", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLStoreFactory_create" "', argument " "1"" of type '" "FIX::MySQLStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MySQLStoreFactory_create" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MySQLStoreFactory_create" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MySQLStoreFactory_create" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MySQLStoreFactory_create" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MessageStore *)(arg1)->create((FIX::UtcTimeStamp const &)*arg2,(FIX::SessionID const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLStoreFactory_destroy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStoreFactory *arg1 = (FIX::MySQLStoreFactory *) 0 ;
  FIX::MessageStore *arg2 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLStoreFactory_destroy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLStoreFactory_destroy" "', argument " "1"" of type '" "FIX::MySQLStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MySQLStoreFactory_destroy" "', argument " "2"" of type '" "FIX::MessageStore *""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStore * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->destroy(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MySQLStoreFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStoreFactory *arg1 = (FIX::MySQLStoreFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStoreFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MySQLStoreFactory" "', argument " "1"" of type '" "FIX::MySQLStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStoreFactory * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MySQLStoreFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MySQLStoreFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MySQLStoreFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MySQLStore__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStamp *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  FIX::DatabaseConnectionID *arg3 = 0 ;
  FIX::MySQLConnectionPool *arg4 = (FIX::MySQLConnectionPool *) 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 ;
  FIX::MySQLStore *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MySQLStore" "', argument " "1"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStore" "', argument " "1"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStamp * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MySQLStore" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStore" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__DatabaseConnectionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MySQLStore" "', argument " "3"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStore" "', argument " "3"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MySQLStore" "', argument " "4"" of type '" "FIX::MySQLConnectionPool *""'"); 
  }
  arg4 = reinterpret_cast< FIX::MySQLConnectionPool * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLStore *)new FIX::MySQLStore((FIX::UtcTimeStamp const &)*arg1,(FIX::SessionID const &)*arg2,(FIX::DatabaseConnectionID const &)*arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLStore, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLStore__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStamp *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  std::string *arg6 = 0 ;
  short arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  short val7 ;
  int ecode7 = 0 ;
  FIX::MySQLStore *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MySQLStore" "', argument " "1"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStore" "', argument " "1"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStamp * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MySQLStore" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStore" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MySQLStore" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStore" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MySQLStore" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStore" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MySQLStore" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStore" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MySQLStore" "', argument " "6"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLStore" "', argument " "6"" of type '" "std::string const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_short(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MySQLStore" "', argument " "7"" of type '" "short""'");
  } 
  arg7 = static_cast< short >(val7);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLStore *)new FIX::MySQLStore((FIX::UtcTimeStamp const &)*arg1,(FIX::SessionID const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLStore, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg5->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg6->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLStore(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MySQLStore", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_MySQLStore__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_short(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_MySQLStore__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MySQLStore'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MySQLStore::MySQLStore(FIX::UtcTimeStamp const &,FIX::SessionID const &,FIX::DatabaseConnectionID const &,FIX::MySQLConnectionPool *)\n"
    "    FIX::MySQLStore::MySQLStore(FIX::UtcTimeStamp const &,FIX::SessionID const &,std::string const &,std::string const &,std::string const &,std::string const &,short)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MySQLStore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStore *arg1 = (FIX::MySQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStore, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MySQLStore" "', argument " "1"" of type '" "FIX::MySQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLStore_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStore *arg1 = (FIX::MySQLStore *) 0 ;
  FIX::SEQNUM arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLStore_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLStore_set" "', argument " "1"" of type '" "FIX::MySQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MySQLStore_set" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MySQLStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MySQLStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLStore_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStore *arg1 = (FIX::MySQLStore *) 0 ;
  FIX::SEQNUM arg2 ;
  FIX::SEQNUM arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLStore_get", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLStore_get" "', argument " "1"" of type '" "FIX::MySQLStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MySQLStore_get" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MySQLStore_get" "', argument " "3"" of type '" "FIX::SEQNUM""'");
  } 
  arg3 = static_cast< FIX::SEQNUM >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MySQLStore_get" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MySQLStore_get" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            ((FIX::MySQLStore const *)arg1)->get(arg2,arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLStore_getNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStore *arg1 = (FIX::MySQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLStore_getNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MySQLStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)((FIX::MySQLStore const *)arg1)->getNextSenderMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLStore_getNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStore *arg1 = (FIX::MySQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLStore_getNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MySQLStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)((FIX::MySQLStore const *)arg1)->getNextTargetMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLStore_setNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStore *arg1 = (FIX::MySQLStore *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLStore_setNextSenderMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLStore_setNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MySQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MySQLStore_setNextSenderMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextSenderMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLStore_setNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStore *arg1 = (FIX::MySQLStore *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLStore_setNextTargetMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLStore_setNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MySQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MySQLStore_setNextTargetMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextTargetMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLStore_incrNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStore *arg1 = (FIX::MySQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLStore_incrNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MySQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->incrNextSenderMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLStore_incrNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStore *arg1 = (FIX::MySQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLStore_incrNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MySQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->incrNextTargetMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLStore_getCreationTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStore *arg1 = (FIX::MySQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::UtcTimeStamp result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLStore_getCreationTime" "', argument " "1"" of type '" "FIX::MySQLStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::MySQLStore const *)arg1)->getCreationTime();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::UtcTimeStamp(result)), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLStore_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStore *arg1 = (FIX::MySQLStore *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLStore_reset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLStore_reset" "', argument " "1"" of type '" "FIX::MySQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStore * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MySQLStore_reset" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MySQLStore_reset" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->reset((FIX::UtcTimeStamp const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLStore_refresh(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLStore *arg1 = (FIX::MySQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLStore_refresh" "', argument " "1"" of type '" "FIX::MySQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->refresh();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MySQLStore_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MySQLStore, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MySQLStore_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MySQLLog__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  FIX::DatabaseConnectionID *arg2 = 0 ;
  FIX::MySQLConnectionPool *arg3 = (FIX::MySQLConnectionPool *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::MySQLLog *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MySQLLog" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLog" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__DatabaseConnectionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MySQLLog" "', argument " "2"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLog" "', argument " "2"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MySQLLog" "', argument " "3"" of type '" "FIX::MySQLConnectionPool *""'"); 
  }
  arg3 = reinterpret_cast< FIX::MySQLConnectionPool * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLLog *)new FIX::MySQLLog((FIX::SessionID const &)*arg1,(FIX::DatabaseConnectionID const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLLog__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DatabaseConnectionID *arg1 = 0 ;
  FIX::MySQLConnectionPool *arg2 = (FIX::MySQLConnectionPool *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FIX::MySQLLog *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DatabaseConnectionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MySQLLog" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLog" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MySQLLog" "', argument " "2"" of type '" "FIX::MySQLConnectionPool *""'"); 
  }
  arg2 = reinterpret_cast< FIX::MySQLConnectionPool * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLLog *)new FIX::MySQLLog((FIX::DatabaseConnectionID const &)*arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLLog__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  short arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  short val6 ;
  int ecode6 = 0 ;
  FIX::MySQLLog *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MySQLLog" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLog" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MySQLLog" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLog" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MySQLLog" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLog" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MySQLLog" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLog" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MySQLLog" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLog" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    arg5 = ptr;
  }
  ecode6 = SWIG_AsVal_short(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MySQLLog" "', argument " "6"" of type '" "short""'");
  } 
  arg6 = static_cast< short >(val6);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLLog *)new FIX::MySQLLog((FIX::SessionID const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLLog, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg5->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLLog__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  short arg5 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  short val5 ;
  int ecode5 = 0 ;
  FIX::MySQLLog *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MySQLLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MySQLLog" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLog" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MySQLLog" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLog" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MySQLLog" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLog" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MySQLLog" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLLog *)new FIX::MySQLLog((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLLog, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLLog(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MySQLLog", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MySQLLog__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_MySQLLog__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    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) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_MySQLLog__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_MySQLLog__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MySQLLog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MySQLLog::MySQLLog(FIX::SessionID const &,FIX::DatabaseConnectionID const &,FIX::MySQLConnectionPool *)\n"
    "    FIX::MySQLLog::MySQLLog(FIX::DatabaseConnectionID const &,FIX::MySQLConnectionPool *)\n"
    "    FIX::MySQLLog::MySQLLog(FIX::SessionID const &,std::string const &,std::string const &,std::string const &,std::string const &,short)\n"
    "    FIX::MySQLLog::MySQLLog(std::string const &,std::string const &,std::string const &,std::string const &,short)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MySQLLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLLog *arg1 = (FIX::MySQLLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLLog, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MySQLLog" "', argument " "1"" of type '" "FIX::MySQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLLog * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLLog_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLLog *arg1 = (FIX::MySQLLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLLog_clear" "', argument " "1"" of type '" "FIX::MySQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLLog * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->clear();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLLog_backup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLLog *arg1 = (FIX::MySQLLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLLog_backup" "', argument " "1"" of type '" "FIX::MySQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLLog * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->backup();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLLog_setIncomingTable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLLog *arg1 = (FIX::MySQLLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLLog_setIncomingTable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLLog_setIncomingTable" "', argument " "1"" of type '" "FIX::MySQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MySQLLog_setIncomingTable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MySQLLog_setIncomingTable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setIncomingTable((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLLog_setOutgoingTable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLLog *arg1 = (FIX::MySQLLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLLog_setOutgoingTable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLLog_setOutgoingTable" "', argument " "1"" of type '" "FIX::MySQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MySQLLog_setOutgoingTable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MySQLLog_setOutgoingTable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setOutgoingTable((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLLog_setEventTable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLLog *arg1 = (FIX::MySQLLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLLog_setEventTable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLLog_setEventTable" "', argument " "1"" of type '" "FIX::MySQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MySQLLog_setEventTable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MySQLLog_setEventTable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setEventTable((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLLog_onIncoming(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLLog *arg1 = (FIX::MySQLLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLLog_onIncoming", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLLog_onIncoming" "', argument " "1"" of type '" "FIX::MySQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MySQLLog_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MySQLLog_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onIncoming((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLLog_onOutgoing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLLog *arg1 = (FIX::MySQLLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLLog_onOutgoing", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLLog_onOutgoing" "', argument " "1"" of type '" "FIX::MySQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MySQLLog_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MySQLLog_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onOutgoing((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLLog_onEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLLog *arg1 = (FIX::MySQLLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLLog_onEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLLog_onEvent" "', argument " "1"" of type '" "FIX::MySQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MySQLLog_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MySQLLog_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onEvent((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *MySQLLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MySQLLog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MySQLLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_MySQLLogFactory_DEFAULT_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MySQLLogFactory_DEFAULT_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MySQLLogFactory_DEFAULT_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::MySQLLogFactory::DEFAULT_DATABASE));
  return pyobj;
}


SWIGINTERN int Swig_var_MySQLLogFactory_DEFAULT_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MySQLLogFactory_DEFAULT_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MySQLLogFactory_DEFAULT_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::MySQLLogFactory::DEFAULT_USER));
  return pyobj;
}


SWIGINTERN int Swig_var_MySQLLogFactory_DEFAULT_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MySQLLogFactory_DEFAULT_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MySQLLogFactory_DEFAULT_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::MySQLLogFactory::DEFAULT_PASSWORD));
  return pyobj;
}


SWIGINTERN int Swig_var_MySQLLogFactory_DEFAULT_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MySQLLogFactory_DEFAULT_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MySQLLogFactory_DEFAULT_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::MySQLLogFactory::DEFAULT_HOST));
  return pyobj;
}


SWIGINTERN int Swig_var_MySQLLogFactory_DEFAULT_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MySQLLogFactory_DEFAULT_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MySQLLogFactory_DEFAULT_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_short(static_cast< short >(FIX::MySQLLogFactory::DEFAULT_PORT));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_MySQLLogFactory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::MySQLLogFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MySQLLogFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLogFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLLogFactory *)new FIX::MySQLLogFactory((FIX::SessionSettings const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLLogFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLLogFactory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  short arg5 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  short val5 ;
  int ecode5 = 0 ;
  FIX::MySQLLogFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MySQLLogFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLogFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MySQLLogFactory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLogFactory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MySQLLogFactory" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLogFactory" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MySQLLogFactory" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MySQLLogFactory" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MySQLLogFactory" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLLogFactory *)new FIX::MySQLLogFactory((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLLogFactory, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLLogFactory__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::MySQLLogFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MySQLLogFactory *)new FIX::MySQLLogFactory();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MySQLLogFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MySQLLogFactory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MySQLLogFactory", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MySQLLogFactory__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MySQLLogFactory__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v = 0;
    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) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_MySQLLogFactory__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MySQLLogFactory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MySQLLogFactory::MySQLLogFactory(FIX::SessionSettings const &)\n"
    "    FIX::MySQLLogFactory::MySQLLogFactory(std::string const &,std::string const &,std::string const &,std::string const &,short)\n"
    "    FIX::MySQLLogFactory::MySQLLogFactory()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MySQLLogFactory_create__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::MySQLLogFactory *arg1 = (FIX::MySQLLogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  FIX::Log *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLLogFactory_create" "', argument " "1"" of type '" "FIX::MySQLLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLLogFactory * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Log *)(arg1)->create();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLLogFactory_create__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::MySQLLogFactory *arg1 = (FIX::MySQLLogFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  FIX::Log *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLLogFactory_create" "', argument " "1"" of type '" "FIX::MySQLLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLLogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MySQLLogFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MySQLLogFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Log *)(arg1)->create((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MySQLLogFactory_create(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MySQLLogFactory_create", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MySQLLogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MySQLLogFactory_create__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MySQLLogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MySQLLogFactory_create__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MySQLLogFactory_create'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MySQLLogFactory::create()\n"
    "    FIX::MySQLLogFactory::create(FIX::SessionID const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MySQLLogFactory_destroy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLLogFactory *arg1 = (FIX::MySQLLogFactory *) 0 ;
  FIX::Log *arg2 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MySQLLogFactory_destroy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MySQLLogFactory_destroy" "', argument " "1"" of type '" "FIX::MySQLLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLLogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MySQLLogFactory_destroy" "', argument " "2"" of type '" "FIX::Log *""'"); 
  }
  arg2 = reinterpret_cast< FIX::Log * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->destroy(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MySQLLogFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MySQLLogFactory *arg1 = (FIX::MySQLLogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__MySQLLogFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MySQLLogFactory" "', argument " "1"" of type '" "FIX::MySQLLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MySQLLogFactory * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MySQLLogFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MySQLLogFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MySQLLogFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PostgreSQLQuery(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  FIX::PostgreSQLQuery *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostgreSQLQuery" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLQuery" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLQuery *)new FIX::PostgreSQLQuery((std::string const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLQuery, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PostgreSQLQuery(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLQuery *arg1 = (FIX::PostgreSQLQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLQuery, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PostgreSQLQuery" "', argument " "1"" of type '" "FIX::PostgreSQLQuery *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLQuery * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLQuery_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLQuery *arg1 = (FIX::PostgreSQLQuery *) 0 ;
  PGconn *arg2 = (PGconn *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLQuery_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLQuery_execute" "', argument " "1"" of type '" "FIX::PostgreSQLQuery *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLQuery * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_PGconn, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostgreSQLQuery_execute" "', argument " "2"" of type '" "PGconn *""'"); 
  }
  arg2 = reinterpret_cast< PGconn * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->execute(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLQuery_success(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLQuery *arg1 = (FIX::PostgreSQLQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLQuery_success" "', argument " "1"" of type '" "FIX::PostgreSQLQuery *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLQuery * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->success();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLQuery_rows(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLQuery *arg1 = (FIX::PostgreSQLQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLQuery_rows" "', argument " "1"" of type '" "FIX::PostgreSQLQuery *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLQuery * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (int)(arg1)->rows();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLQuery_reason(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLQuery *arg1 = (FIX::PostgreSQLQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLQuery_reason" "', argument " "1"" of type '" "FIX::PostgreSQLQuery *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLQuery * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (char *)(arg1)->reason();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLQuery_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLQuery *arg1 = (FIX::PostgreSQLQuery *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLQuery_getValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLQuery_getValue" "', argument " "1"" of type '" "FIX::PostgreSQLQuery *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLQuery * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PostgreSQLQuery_getValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PostgreSQLQuery_getValue" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (char *)(arg1)->getValue(arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLQuery_throwException(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLQuery *arg1 = (FIX::PostgreSQLQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLQuery_throwException" "', argument " "1"" of type '" "FIX::PostgreSQLQuery *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLQuery * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->throwException();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PostgreSQLQuery_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PostgreSQLQuery, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PostgreSQLQuery_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PostgreSQLConnection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DatabaseConnectionID *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::PostgreSQLConnection *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DatabaseConnectionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostgreSQLConnection" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLConnection" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLConnection *)new FIX::PostgreSQLConnection((FIX::DatabaseConnectionID const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLConnection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLConnection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  short arg5 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  short val5 ;
  int ecode5 = 0 ;
  FIX::PostgreSQLConnection *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostgreSQLConnection" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLConnection" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PostgreSQLConnection" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLConnection" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PostgreSQLConnection" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLConnection" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PostgreSQLConnection" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLConnection" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PostgreSQLConnection" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLConnection *)new FIX::PostgreSQLConnection((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLConnection, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLConnection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PostgreSQLConnection", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PostgreSQLConnection__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v = 0;
    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) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_PostgreSQLConnection__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PostgreSQLConnection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PostgreSQLConnection::PostgreSQLConnection(FIX::DatabaseConnectionID const &)\n"
    "    FIX::PostgreSQLConnection::PostgreSQLConnection(std::string const &,std::string const &,std::string const &,std::string const &,short)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PostgreSQLConnection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLConnection *arg1 = (FIX::PostgreSQLConnection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLConnection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PostgreSQLConnection" "', argument " "1"" of type '" "FIX::PostgreSQLConnection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLConnection * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLConnection_connectionID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLConnection *arg1 = (FIX::PostgreSQLConnection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::DatabaseConnectionID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLConnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLConnection_connectionID" "', argument " "1"" of type '" "FIX::PostgreSQLConnection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLConnection * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::DatabaseConnectionID *) &(arg1)->connectionID();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DatabaseConnectionID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLConnection_connected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLConnection *arg1 = (FIX::PostgreSQLConnection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLConnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLConnection_connected" "', argument " "1"" of type '" "FIX::PostgreSQLConnection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLConnection * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->connected();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLConnection_reconnect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLConnection *arg1 = (FIX::PostgreSQLConnection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLConnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLConnection_reconnect" "', argument " "1"" of type '" "FIX::PostgreSQLConnection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLConnection * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->reconnect();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLConnection_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLConnection *arg1 = (FIX::PostgreSQLConnection *) 0 ;
  FIX::PostgreSQLQuery *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLConnection_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLConnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLConnection_execute" "', argument " "1"" of type '" "FIX::PostgreSQLConnection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLConnection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__PostgreSQLQuery,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostgreSQLConnection_execute" "', argument " "2"" of type '" "FIX::PostgreSQLQuery &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PostgreSQLConnection_execute" "', argument " "2"" of type '" "FIX::PostgreSQLQuery &""'"); 
  }
  arg2 = reinterpret_cast< FIX::PostgreSQLQuery * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->execute(*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PostgreSQLConnection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PostgreSQLConnection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PostgreSQLConnection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_PostgreSQLStoreFactory_DEFAULT_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostgreSQLStoreFactory_DEFAULT_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostgreSQLStoreFactory_DEFAULT_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::PostgreSQLStoreFactory::DEFAULT_DATABASE));
  return pyobj;
}


SWIGINTERN int Swig_var_PostgreSQLStoreFactory_DEFAULT_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostgreSQLStoreFactory_DEFAULT_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostgreSQLStoreFactory_DEFAULT_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::PostgreSQLStoreFactory::DEFAULT_USER));
  return pyobj;
}


SWIGINTERN int Swig_var_PostgreSQLStoreFactory_DEFAULT_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostgreSQLStoreFactory_DEFAULT_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostgreSQLStoreFactory_DEFAULT_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::PostgreSQLStoreFactory::DEFAULT_PASSWORD));
  return pyobj;
}


SWIGINTERN int Swig_var_PostgreSQLStoreFactory_DEFAULT_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostgreSQLStoreFactory_DEFAULT_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostgreSQLStoreFactory_DEFAULT_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::PostgreSQLStoreFactory::DEFAULT_HOST));
  return pyobj;
}


SWIGINTERN int Swig_var_PostgreSQLStoreFactory_DEFAULT_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostgreSQLStoreFactory_DEFAULT_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostgreSQLStoreFactory_DEFAULT_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_short(static_cast< short >(FIX::PostgreSQLStoreFactory::DEFAULT_PORT));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLStoreFactory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::PostgreSQLStoreFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostgreSQLStoreFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStoreFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLStoreFactory *)new FIX::PostgreSQLStoreFactory((FIX::SessionSettings const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLStoreFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLStoreFactory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::PostgreSQLStoreFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__Dictionary,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostgreSQLStoreFactory" "', argument " "1"" of type '" "FIX::Dictionary const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStoreFactory" "', argument " "1"" of type '" "FIX::Dictionary const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLStoreFactory *)new FIX::PostgreSQLStoreFactory((FIX::Dictionary const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLStoreFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLStoreFactory__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  short arg5 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  short val5 ;
  int ecode5 = 0 ;
  FIX::PostgreSQLStoreFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostgreSQLStoreFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStoreFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PostgreSQLStoreFactory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStoreFactory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PostgreSQLStoreFactory" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStoreFactory" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PostgreSQLStoreFactory" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStoreFactory" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PostgreSQLStoreFactory" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLStoreFactory *)new FIX::PostgreSQLStoreFactory((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLStoreFactory, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLStoreFactory__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStoreFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLStoreFactory *)new FIX::PostgreSQLStoreFactory();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLStoreFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLStoreFactory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PostgreSQLStoreFactory", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_PostgreSQLStoreFactory__SWIG_3(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__Dictionary, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PostgreSQLStoreFactory__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PostgreSQLStoreFactory__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v = 0;
    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) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_PostgreSQLStoreFactory__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PostgreSQLStoreFactory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PostgreSQLStoreFactory::PostgreSQLStoreFactory(FIX::SessionSettings const &)\n"
    "    FIX::PostgreSQLStoreFactory::PostgreSQLStoreFactory(FIX::Dictionary const &)\n"
    "    FIX::PostgreSQLStoreFactory::PostgreSQLStoreFactory(std::string const &,std::string const &,std::string const &,std::string const &,short)\n"
    "    FIX::PostgreSQLStoreFactory::PostgreSQLStoreFactory()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PostgreSQLStoreFactory_create(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStoreFactory *arg1 = (FIX::PostgreSQLStoreFactory *) 0 ;
  FIX::UtcTimeStamp *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 *swig_obj[3] ;
  FIX::MessageStore *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLStoreFactory_create", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLStoreFactory_create" "', argument " "1"" of type '" "FIX::PostgreSQLStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostgreSQLStoreFactory_create" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PostgreSQLStoreFactory_create" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PostgreSQLStoreFactory_create" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PostgreSQLStoreFactory_create" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MessageStore *)(arg1)->create((FIX::UtcTimeStamp const &)*arg2,(FIX::SessionID const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLStoreFactory_destroy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStoreFactory *arg1 = (FIX::PostgreSQLStoreFactory *) 0 ;
  FIX::MessageStore *arg2 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLStoreFactory_destroy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLStoreFactory_destroy" "', argument " "1"" of type '" "FIX::PostgreSQLStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostgreSQLStoreFactory_destroy" "', argument " "2"" of type '" "FIX::MessageStore *""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStore * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->destroy(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PostgreSQLStoreFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStoreFactory *arg1 = (FIX::PostgreSQLStoreFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStoreFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PostgreSQLStoreFactory" "', argument " "1"" of type '" "FIX::PostgreSQLStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStoreFactory * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PostgreSQLStoreFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PostgreSQLStoreFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PostgreSQLStoreFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PostgreSQLStore__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStamp *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  FIX::DatabaseConnectionID *arg3 = 0 ;
  FIX::PostgreSQLConnectionPool *arg4 = (FIX::PostgreSQLConnectionPool *) 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 ;
  FIX::PostgreSQLStore *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostgreSQLStore" "', argument " "1"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStore" "', argument " "1"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStamp * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PostgreSQLStore" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStore" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__DatabaseConnectionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PostgreSQLStore" "', argument " "3"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStore" "', argument " "3"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PostgreSQLStore" "', argument " "4"" of type '" "FIX::PostgreSQLConnectionPool *""'"); 
  }
  arg4 = reinterpret_cast< FIX::PostgreSQLConnectionPool * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLStore *)new FIX::PostgreSQLStore((FIX::UtcTimeStamp const &)*arg1,(FIX::SessionID const &)*arg2,(FIX::DatabaseConnectionID const &)*arg3,arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLStore, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLStore__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStamp *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  std::string *arg6 = 0 ;
  short arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  short val7 ;
  int ecode7 = 0 ;
  FIX::PostgreSQLStore *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostgreSQLStore" "', argument " "1"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStore" "', argument " "1"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStamp * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PostgreSQLStore" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStore" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PostgreSQLStore" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStore" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PostgreSQLStore" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStore" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PostgreSQLStore" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStore" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PostgreSQLStore" "', argument " "6"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLStore" "', argument " "6"" of type '" "std::string const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_short(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PostgreSQLStore" "', argument " "7"" of type '" "short""'");
  } 
  arg7 = static_cast< short >(val7);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLStore *)new FIX::PostgreSQLStore((FIX::UtcTimeStamp const &)*arg1,(FIX::SessionID const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLStore, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg5->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg6->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLStore(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PostgreSQLStore", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PostgreSQLStore__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_short(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_PostgreSQLStore__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PostgreSQLStore'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PostgreSQLStore::PostgreSQLStore(FIX::UtcTimeStamp const &,FIX::SessionID const &,FIX::DatabaseConnectionID const &,FIX::PostgreSQLConnectionPool *)\n"
    "    FIX::PostgreSQLStore::PostgreSQLStore(FIX::UtcTimeStamp const &,FIX::SessionID const &,std::string const &,std::string const &,std::string const &,std::string const &,short)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PostgreSQLStore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PostgreSQLStore" "', argument " "1"" of type '" "FIX::PostgreSQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLStore_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  FIX::SEQNUM arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLStore_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLStore_set" "', argument " "1"" of type '" "FIX::PostgreSQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PostgreSQLStore_set" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PostgreSQLStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PostgreSQLStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLStore_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  FIX::SEQNUM arg2 ;
  FIX::SEQNUM arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLStore_get", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLStore_get" "', argument " "1"" of type '" "FIX::PostgreSQLStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PostgreSQLStore_get" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PostgreSQLStore_get" "', argument " "3"" of type '" "FIX::SEQNUM""'");
  } 
  arg3 = static_cast< FIX::SEQNUM >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PostgreSQLStore_get" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PostgreSQLStore_get" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            ((FIX::PostgreSQLStore const *)arg1)->get(arg2,arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLStore_getNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLStore_getNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::PostgreSQLStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)((FIX::PostgreSQLStore const *)arg1)->getNextSenderMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLStore_getNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLStore_getNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::PostgreSQLStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)((FIX::PostgreSQLStore const *)arg1)->getNextTargetMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLStore_setNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLStore_setNextSenderMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLStore_setNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::PostgreSQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PostgreSQLStore_setNextSenderMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextSenderMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLStore_setNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLStore_setNextTargetMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLStore_setNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::PostgreSQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PostgreSQLStore_setNextTargetMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextTargetMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLStore_incrNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLStore_incrNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::PostgreSQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->incrNextSenderMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLStore_incrNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLStore_incrNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::PostgreSQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->incrNextTargetMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLStore_getCreationTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::UtcTimeStamp result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLStore_getCreationTime" "', argument " "1"" of type '" "FIX::PostgreSQLStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::PostgreSQLStore const *)arg1)->getCreationTime();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::UtcTimeStamp(result)), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLStore_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLStore_reset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLStore_reset" "', argument " "1"" of type '" "FIX::PostgreSQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostgreSQLStore_reset" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PostgreSQLStore_reset" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->reset((FIX::UtcTimeStamp const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLStore_refresh(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLStore_refresh" "', argument " "1"" of type '" "FIX::PostgreSQLStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->refresh();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PostgreSQLStore_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PostgreSQLStore, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PostgreSQLStore_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PostgreSQLLog__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  FIX::DatabaseConnectionID *arg2 = 0 ;
  FIX::PostgreSQLConnectionPool *arg3 = (FIX::PostgreSQLConnectionPool *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::PostgreSQLLog *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostgreSQLLog" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLog" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__DatabaseConnectionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PostgreSQLLog" "', argument " "2"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLog" "', argument " "2"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PostgreSQLLog" "', argument " "3"" of type '" "FIX::PostgreSQLConnectionPool *""'"); 
  }
  arg3 = reinterpret_cast< FIX::PostgreSQLConnectionPool * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLLog *)new FIX::PostgreSQLLog((FIX::SessionID const &)*arg1,(FIX::DatabaseConnectionID const &)*arg2,arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLLog__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::DatabaseConnectionID *arg1 = 0 ;
  FIX::PostgreSQLConnectionPool *arg2 = (FIX::PostgreSQLConnectionPool *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FIX::PostgreSQLLog *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__DatabaseConnectionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostgreSQLLog" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLog" "', argument " "1"" of type '" "FIX::DatabaseConnectionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DatabaseConnectionID * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PostgreSQLLog" "', argument " "2"" of type '" "FIX::PostgreSQLConnectionPool *""'"); 
  }
  arg2 = reinterpret_cast< FIX::PostgreSQLConnectionPool * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLLog *)new FIX::PostgreSQLLog((FIX::DatabaseConnectionID const &)*arg1,arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLLog__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  short arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  short val6 ;
  int ecode6 = 0 ;
  FIX::PostgreSQLLog *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostgreSQLLog" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLog" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PostgreSQLLog" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLog" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PostgreSQLLog" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLog" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PostgreSQLLog" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLog" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PostgreSQLLog" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLog" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    arg5 = ptr;
  }
  ecode6 = SWIG_AsVal_short(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PostgreSQLLog" "', argument " "6"" of type '" "short""'");
  } 
  arg6 = static_cast< short >(val6);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLLog *)new FIX::PostgreSQLLog((FIX::SessionID const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLLog, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg5->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLLog__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  short arg5 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  short val5 ;
  int ecode5 = 0 ;
  FIX::PostgreSQLLog *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostgreSQLLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PostgreSQLLog" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLog" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PostgreSQLLog" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLog" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PostgreSQLLog" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLog" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PostgreSQLLog" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLLog *)new FIX::PostgreSQLLog((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLLog, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLLog(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PostgreSQLLog", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_PostgreSQLLog__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PostgreSQLLog__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    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) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_PostgreSQLLog__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_PostgreSQLLog__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PostgreSQLLog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PostgreSQLLog::PostgreSQLLog(FIX::SessionID const &,FIX::DatabaseConnectionID const &,FIX::PostgreSQLConnectionPool *)\n"
    "    FIX::PostgreSQLLog::PostgreSQLLog(FIX::DatabaseConnectionID const &,FIX::PostgreSQLConnectionPool *)\n"
    "    FIX::PostgreSQLLog::PostgreSQLLog(FIX::SessionID const &,std::string const &,std::string const &,std::string const &,std::string const &,short)\n"
    "    FIX::PostgreSQLLog::PostgreSQLLog(std::string const &,std::string const &,std::string const &,std::string const &,short)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PostgreSQLLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLLog *arg1 = (FIX::PostgreSQLLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLLog, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PostgreSQLLog" "', argument " "1"" of type '" "FIX::PostgreSQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLLog * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLLog_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLLog *arg1 = (FIX::PostgreSQLLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLLog_clear" "', argument " "1"" of type '" "FIX::PostgreSQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLLog * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->clear();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLLog_backup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLLog *arg1 = (FIX::PostgreSQLLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLLog_backup" "', argument " "1"" of type '" "FIX::PostgreSQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLLog * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->backup();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLLog_setIncomingTable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLLog *arg1 = (FIX::PostgreSQLLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLLog_setIncomingTable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLLog_setIncomingTable" "', argument " "1"" of type '" "FIX::PostgreSQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostgreSQLLog_setIncomingTable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PostgreSQLLog_setIncomingTable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setIncomingTable((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLLog_setOutgoingTable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLLog *arg1 = (FIX::PostgreSQLLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLLog_setOutgoingTable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLLog_setOutgoingTable" "', argument " "1"" of type '" "FIX::PostgreSQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostgreSQLLog_setOutgoingTable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PostgreSQLLog_setOutgoingTable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setOutgoingTable((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLLog_setEventTable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLLog *arg1 = (FIX::PostgreSQLLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLLog_setEventTable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLLog_setEventTable" "', argument " "1"" of type '" "FIX::PostgreSQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostgreSQLLog_setEventTable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PostgreSQLLog_setEventTable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setEventTable((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLLog_onIncoming(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLLog *arg1 = (FIX::PostgreSQLLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLLog_onIncoming", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLLog_onIncoming" "', argument " "1"" of type '" "FIX::PostgreSQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostgreSQLLog_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PostgreSQLLog_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onIncoming((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLLog_onOutgoing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLLog *arg1 = (FIX::PostgreSQLLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLLog_onOutgoing", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLLog_onOutgoing" "', argument " "1"" of type '" "FIX::PostgreSQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostgreSQLLog_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PostgreSQLLog_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onOutgoing((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLLog_onEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLLog *arg1 = (FIX::PostgreSQLLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLLog_onEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLLog_onEvent" "', argument " "1"" of type '" "FIX::PostgreSQLLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostgreSQLLog_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PostgreSQLLog_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->onEvent((std::string const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *PostgreSQLLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PostgreSQLLog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PostgreSQLLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_PostgreSQLLogFactory_DEFAULT_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostgreSQLLogFactory_DEFAULT_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostgreSQLLogFactory_DEFAULT_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::PostgreSQLLogFactory::DEFAULT_DATABASE));
  return pyobj;
}


SWIGINTERN int Swig_var_PostgreSQLLogFactory_DEFAULT_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostgreSQLLogFactory_DEFAULT_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostgreSQLLogFactory_DEFAULT_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::PostgreSQLLogFactory::DEFAULT_USER));
  return pyobj;
}


SWIGINTERN int Swig_var_PostgreSQLLogFactory_DEFAULT_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostgreSQLLogFactory_DEFAULT_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostgreSQLLogFactory_DEFAULT_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::PostgreSQLLogFactory::DEFAULT_PASSWORD));
  return pyobj;
}


SWIGINTERN int Swig_var_PostgreSQLLogFactory_DEFAULT_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostgreSQLLogFactory_DEFAULT_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostgreSQLLogFactory_DEFAULT_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(FIX::PostgreSQLLogFactory::DEFAULT_HOST));
  return pyobj;
}


SWIGINTERN int Swig_var_PostgreSQLLogFactory_DEFAULT_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PostgreSQLLogFactory_DEFAULT_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PostgreSQLLogFactory_DEFAULT_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_short(static_cast< short >(FIX::PostgreSQLLogFactory::DEFAULT_PORT));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLLogFactory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::PostgreSQLLogFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostgreSQLLogFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLogFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLLogFactory *)new FIX::PostgreSQLLogFactory((FIX::SessionSettings const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLLogFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLLogFactory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  short arg5 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  short val5 ;
  int ecode5 = 0 ;
  FIX::PostgreSQLLogFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostgreSQLLogFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLogFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PostgreSQLLogFactory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLogFactory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PostgreSQLLogFactory" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLogFactory" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PostgreSQLLogFactory" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PostgreSQLLogFactory" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PostgreSQLLogFactory" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLLogFactory *)new FIX::PostgreSQLLogFactory((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLLogFactory, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLLogFactory__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLLogFactory *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::PostgreSQLLogFactory *)new FIX::PostgreSQLLogFactory();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PostgreSQLLogFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PostgreSQLLogFactory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PostgreSQLLogFactory", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_PostgreSQLLogFactory__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PostgreSQLLogFactory__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v = 0;
    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) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_PostgreSQLLogFactory__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PostgreSQLLogFactory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PostgreSQLLogFactory::PostgreSQLLogFactory(FIX::SessionSettings const &)\n"
    "    FIX::PostgreSQLLogFactory::PostgreSQLLogFactory(std::string const &,std::string const &,std::string const &,std::string const &,short)\n"
    "    FIX::PostgreSQLLogFactory::PostgreSQLLogFactory()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PostgreSQLLogFactory_create__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLLogFactory *arg1 = (FIX::PostgreSQLLogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  FIX::Log *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLLogFactory_create" "', argument " "1"" of type '" "FIX::PostgreSQLLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLLogFactory * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Log *)(arg1)->create();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLLogFactory_create__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLLogFactory *arg1 = (FIX::PostgreSQLLogFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  FIX::Log *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLLogFactory_create" "', argument " "1"" of type '" "FIX::PostgreSQLLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLLogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostgreSQLLogFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PostgreSQLLogFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::Log *)(arg1)->create((FIX::SessionID const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostgreSQLLogFactory_create(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PostgreSQLLogFactory_create", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PostgreSQLLogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PostgreSQLLogFactory_create__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PostgreSQLLogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PostgreSQLLogFactory_create__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PostgreSQLLogFactory_create'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PostgreSQLLogFactory::create()\n"
    "    FIX::PostgreSQLLogFactory::create(FIX::SessionID const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PostgreSQLLogFactory_destroy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLLogFactory *arg1 = (FIX::PostgreSQLLogFactory *) 0 ;
  FIX::Log *arg2 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostgreSQLLogFactory_destroy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostgreSQLLogFactory_destroy" "', argument " "1"" of type '" "FIX::PostgreSQLLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLLogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostgreSQLLogFactory_destroy" "', argument " "2"" of type '" "FIX::Log *""'"); 
  }
  arg2 = reinterpret_cast< FIX::Log * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->destroy(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PostgreSQLLogFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PostgreSQLLogFactory *arg1 = (FIX::PostgreSQLLogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__PostgreSQLLogFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PostgreSQLLogFactory" "', argument " "1"" of type '" "FIX::PostgreSQLLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLLogFactory * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PostgreSQLLogFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PostgreSQLLogFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PostgreSQLLogFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ThreadedSocketAcceptorBase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::ThreadedSocketAcceptor *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ThreadedSocketAcceptorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ThreadedSocketAcceptorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ThreadedSocketAcceptorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ThreadedSocketAcceptorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ThreadedSocketAcceptorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ThreadedSocketAcceptorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::ThreadedSocketAcceptor *)new FIX::ThreadedSocketAcceptor(*arg1,*arg2,(FIX::SessionSettings const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ThreadedSocketAcceptor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ThreadedSocketAcceptorBase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *arg3 = 0 ;
  FIX::LogFactory *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FIX::ThreadedSocketAcceptor *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ThreadedSocketAcceptorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ThreadedSocketAcceptorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ThreadedSocketAcceptorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ThreadedSocketAcceptorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ThreadedSocketAcceptorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ThreadedSocketAcceptorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FIX__LogFactory,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ThreadedSocketAcceptorBase" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ThreadedSocketAcceptorBase" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  arg4 = reinterpret_cast< FIX::LogFactory * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::ThreadedSocketAcceptor *)new FIX::ThreadedSocketAcceptor(*arg1,*arg2,(FIX::SessionSettings const &)*arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ThreadedSocketAcceptor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ThreadedSocketAcceptorBase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ThreadedSocketAcceptorBase", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ThreadedSocketAcceptorBase__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__LogFactory, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ThreadedSocketAcceptorBase__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ThreadedSocketAcceptorBase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ThreadedSocketAcceptor::ThreadedSocketAcceptor(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &)\n"
    "    FIX::ThreadedSocketAcceptor::ThreadedSocketAcceptor(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &,FIX::LogFactory &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ThreadedSocketAcceptorBase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ThreadedSocketAcceptor *arg1 = (FIX::ThreadedSocketAcceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__ThreadedSocketAcceptor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ThreadedSocketAcceptorBase" "', argument " "1"" of type '" "FIX::ThreadedSocketAcceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ThreadedSocketAcceptor * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ThreadedSocketAcceptorBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ThreadedSocketAcceptor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ThreadedSocketAcceptorBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ThreadedSocketInitiatorBase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::ThreadedSocketInitiator *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ThreadedSocketInitiatorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ThreadedSocketInitiatorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ThreadedSocketInitiatorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ThreadedSocketInitiatorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ThreadedSocketInitiatorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ThreadedSocketInitiatorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::ThreadedSocketInitiator *)new FIX::ThreadedSocketInitiator(*arg1,*arg2,(FIX::SessionSettings const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ThreadedSocketInitiator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ThreadedSocketInitiatorBase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *arg3 = 0 ;
  FIX::LogFactory *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FIX::ThreadedSocketInitiator *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ThreadedSocketInitiatorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ThreadedSocketInitiatorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ThreadedSocketInitiatorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ThreadedSocketInitiatorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ThreadedSocketInitiatorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ThreadedSocketInitiatorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FIX__LogFactory,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ThreadedSocketInitiatorBase" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ThreadedSocketInitiatorBase" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  arg4 = reinterpret_cast< FIX::LogFactory * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::ThreadedSocketInitiator *)new FIX::ThreadedSocketInitiator(*arg1,*arg2,(FIX::SessionSettings const &)*arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ThreadedSocketInitiator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ThreadedSocketInitiatorBase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ThreadedSocketInitiatorBase", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ThreadedSocketInitiatorBase__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__LogFactory, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ThreadedSocketInitiatorBase__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ThreadedSocketInitiatorBase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ThreadedSocketInitiator::ThreadedSocketInitiator(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &)\n"
    "    FIX::ThreadedSocketInitiator::ThreadedSocketInitiator(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &,FIX::LogFactory &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ThreadedSocketInitiatorBase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ThreadedSocketInitiator *arg1 = (FIX::ThreadedSocketInitiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__ThreadedSocketInitiator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ThreadedSocketInitiatorBase" "', argument " "1"" of type '" "FIX::ThreadedSocketInitiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ThreadedSocketInitiator * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ThreadedSocketInitiatorBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ThreadedSocketInitiator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ThreadedSocketInitiatorBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_NullStoreFactory_create(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStoreFactory *arg1 = (FIX::NullStoreFactory *) 0 ;
  FIX::UtcTimeStamp *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 *swig_obj[3] ;
  FIX::MessageStore *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NullStoreFactory_create", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullStoreFactory_create" "', argument " "1"" of type '" "FIX::NullStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NullStoreFactory_create" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "NullStoreFactory_create" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NullStoreFactory_create" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "NullStoreFactory_create" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::MessageStore *)(arg1)->create((FIX::UtcTimeStamp const &)*arg2,(FIX::SessionID const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullStoreFactory_destroy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStoreFactory *arg1 = (FIX::NullStoreFactory *) 0 ;
  FIX::MessageStore *arg2 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NullStoreFactory_destroy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullStoreFactory_destroy" "', argument " "1"" of type '" "FIX::NullStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NullStoreFactory_destroy" "', argument " "2"" of type '" "FIX::MessageStore *""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStore * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->destroy(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NullStoreFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStoreFactory *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_NullStoreFactory", 0, 0, 0)) SWIG_fail;
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::NullStoreFactory *)new FIX::NullStoreFactory();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NullStoreFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NullStoreFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStoreFactory *arg1 = (FIX::NullStoreFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStoreFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NullStoreFactory" "', argument " "1"" of type '" "FIX::NullStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStoreFactory * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NullStoreFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NullStoreFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NullStoreFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NullStore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStamp *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::NullStore *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NullStore" "', argument " "1"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_NullStore" "', argument " "1"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStamp * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::NullStore *)new FIX::NullStore((FIX::UtcTimeStamp const &)*arg1);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NullStore, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullStore_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStore *arg1 = (FIX::NullStore *) 0 ;
  FIX::SEQNUM arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NullStore_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullStore_set" "', argument " "1"" of type '" "FIX::NullStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NullStore_set" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NullStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "NullStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyLong_FromLong(PyDict_Size(resultobj)), PyUnicode_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullStore_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStore *arg1 = (FIX::NullStore *) 0 ;
  FIX::SEQNUM arg2 ;
  FIX::SEQNUM arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NullStore_get", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullStore_get" "', argument " "1"" of type '" "FIX::NullStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NullStore_get" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NullStore_get" "', argument " "3"" of type '" "FIX::SEQNUM""'");
  } 
  arg3 = static_cast< FIX::SEQNUM >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NullStore_get" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "NullStore_get" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp4);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            ((FIX::NullStore const *)arg1)->get(arg2,arg3,*arg4);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullStore_getNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStore *arg1 = (FIX::NullStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullStore_getNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::NullStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)((FIX::NullStore const *)arg1)->getNextSenderMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullStore_getNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStore *arg1 = (FIX::NullStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::SEQNUM result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullStore_getNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::NullStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = (FIX::SEQNUM)((FIX::NullStore const *)arg1)->getNextTargetMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullStore_setNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStore *arg1 = (FIX::NullStore *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NullStore_setNextSenderMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullStore_setNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::NullStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NullStore_setNextSenderMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextSenderMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullStore_setNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStore *arg1 = (FIX::NullStore *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NullStore_setNextTargetMsgSeqNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullStore_setNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::NullStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NullStore_setNextTargetMsgSeqNum" "', argument " "2"" of type '" "FIX::SEQNUM""'");
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setNextTargetMsgSeqNum(arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullStore_incrNextSenderMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStore *arg1 = (FIX::NullStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullStore_incrNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::NullStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->incrNextSenderMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullStore_incrNextTargetMsgSeqNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStore *arg1 = (FIX::NullStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullStore_incrNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::NullStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->incrNextTargetMsgSeqNum();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullStore_setCreationTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStore *arg1 = (FIX::NullStore *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NullStore_setCreationTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullStore_setCreationTime" "', argument " "1"" of type '" "FIX::NullStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStore * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NullStore_setCreationTime" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "NullStore_setCreationTime" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->setCreationTime((FIX::UtcTimeStamp const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullStore_getCreationTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStore *arg1 = (FIX::NullStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FIX::UtcTimeStamp result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullStore_getCreationTime" "', argument " "1"" of type '" "FIX::NullStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            result = ((FIX::NullStore const *)arg1)->getCreationTime();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new FIX::UtcTimeStamp(result)), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullStore_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStore *arg1 = (FIX::NullStore *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "NullStore_reset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullStore_reset" "', argument " "1"" of type '" "FIX::NullStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStore * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NullStore_reset" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "NullStore_reset" "', argument " "2"" of type '" "FIX::UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->reset((FIX::UtcTimeStamp const &)*arg2);
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullStore_refresh(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStore *arg1 = (FIX::NullStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullStore_refresh" "', argument " "1"" of type '" "FIX::NullStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            (arg1)->refresh();
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NullStore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullStore *arg1 = (FIX::NullStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FIX__NullStore, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NullStore" "', argument " "1"" of type '" "FIX::NullStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullStore * >(argp1);
  {
    if(!tryPythonException([&]() mutable
        {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
            delete arg1;
            SWIG_PYTHON_THREAD_END_ALLOW;
          }
          return true;
        fail:
          return false;
        }))
    {
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NullStore_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NullStore, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NullStore_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

static PyMethodDef SwigMethods[] = {
	 { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL},
	 { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, "delete_SwigPyIterator(self)"},
	 { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, "SwigPyIterator_value(self) -> PyObject *"},
	 { "SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, "\n"
		"SwigPyIterator_incr(self, n=1) -> SwigPyIterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: size_t\n"
		"\n"
		""},
	 { "SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, "\n"
		"SwigPyIterator_decr(self, n=1) -> SwigPyIterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: size_t\n"
		"\n"
		""},
	 { "SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, "\n"
		"SwigPyIterator_distance(self, x) -> ptrdiff_t\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: swig::SwigPyIterator const &\n"
		"\n"
		""},
	 { "SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, "\n"
		"SwigPyIterator_equal(self, x) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: swig::SwigPyIterator const &\n"
		"\n"
		""},
	 { "SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_O, "SwigPyIterator_copy(self) -> SwigPyIterator"},
	 { "SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_O, "SwigPyIterator_next(self) -> PyObject *"},
	 { "SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_O, "SwigPyIterator___next__(self) -> PyObject *"},
	 { "SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_O, "SwigPyIterator_previous(self) -> PyObject *"},
	 { "SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, "\n"
		"SwigPyIterator_advance(self, n) -> SwigPyIterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: ptrdiff_t\n"
		"\n"
		""},
	 { "SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, "\n"
		"SwigPyIterator___eq__(self, x) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: swig::SwigPyIterator const &\n"
		"\n"
		""},
	 { "SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, "\n"
		"SwigPyIterator___ne__(self, x) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: swig::SwigPyIterator const &\n"
		"\n"
		""},
	 { "SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, "\n"
		"SwigPyIterator___iadd__(self, n) -> SwigPyIterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: ptrdiff_t\n"
		"\n"
		""},
	 { "SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, "\n"
		"SwigPyIterator___isub__(self, n) -> SwigPyIterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: ptrdiff_t\n"
		"\n"
		""},
	 { "SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, "\n"
		"SwigPyIterator___add__(self, n) -> SwigPyIterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: ptrdiff_t\n"
		"\n"
		""},
	 { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, "\n"
		"SwigPyIterator___sub__(self, n) -> SwigPyIterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: ptrdiff_t\n"
		"\n"
		"SwigPyIterator___sub__(self, x) -> ptrdiff_t\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: swig::SwigPyIterator const &\n"
		"\n"
		""},
	 { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
	 { "VectorString_iterator", _wrap_VectorString_iterator, METH_O, "VectorString_iterator(self) -> SwigPyIterator"},
	 { "VectorString___nonzero__", _wrap_VectorString___nonzero__, METH_O, "VectorString___nonzero__(self) -> bool"},
	 { "VectorString___bool__", _wrap_VectorString___bool__, METH_O, "VectorString___bool__(self) -> bool"},
	 { "VectorString___len__", _wrap_VectorString___len__, METH_O, "VectorString___len__(self) -> std::vector< std::string >::size_type"},
	 { "VectorString___getslice__", _wrap_VectorString___getslice__, METH_VARARGS, "\n"
		"VectorString___getslice__(self, i, j) -> VectorString\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::vector< std::string >::difference_type\n"
		"j: std::vector< std::string >::difference_type\n"
		"\n"
		""},
	 { "VectorString___setslice__", _wrap_VectorString___setslice__, METH_VARARGS, "\n"
		"VectorString___setslice__(self, i, j)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::vector< std::string >::difference_type\n"
		"j: std::vector< std::string >::difference_type\n"
		"\n"
		"VectorString___setslice__(self, i, j, v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::vector< std::string >::difference_type\n"
		"j: std::vector< std::string >::difference_type\n"
		"v: std::vector< std::string,std::allocator< std::string > > const &\n"
		"\n"
		""},
	 { "VectorString___delslice__", _wrap_VectorString___delslice__, METH_VARARGS, "\n"
		"VectorString___delslice__(self, i, j)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::vector< std::string >::difference_type\n"
		"j: std::vector< std::string >::difference_type\n"
		"\n"
		""},
	 { "VectorString___delitem__", _wrap_VectorString___delitem__, METH_VARARGS, "\n"
		"VectorString___delitem__(self, i)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::vector< std::string >::difference_type\n"
		"\n"
		"VectorString___delitem__(self, slice)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"slice: PySliceObject *\n"
		"\n"
		""},
	 { "VectorString___getitem__", _wrap_VectorString___getitem__, METH_VARARGS, "\n"
		"VectorString___getitem__(self, slice) -> VectorString\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"slice: PySliceObject *\n"
		"\n"
		"VectorString___getitem__(self, i) -> std::vector< std::string >::value_type const &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::vector< std::string >::difference_type\n"
		"\n"
		""},
	 { "VectorString___setitem__", _wrap_VectorString___setitem__, METH_VARARGS, "\n"
		"VectorString___setitem__(self, slice, v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"slice: PySliceObject *\n"
		"v: std::vector< std::string,std::allocator< std::string > > const &\n"
		"\n"
		"VectorString___setitem__(self, slice)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"slice: PySliceObject *\n"
		"\n"
		"VectorString___setitem__(self, i, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::vector< std::string >::difference_type\n"
		"x: std::vector< std::string >::value_type const &\n"
		"\n"
		""},
	 { "VectorString_pop", _wrap_VectorString_pop, METH_O, "VectorString_pop(self) -> std::vector< std::string >::value_type"},
	 { "VectorString_append", _wrap_VectorString_append, METH_VARARGS, "\n"
		"VectorString_append(self, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::vector< std::string >::value_type const &\n"
		"\n"
		""},
	 { "VectorString_empty", _wrap_VectorString_empty, METH_O, "VectorString_empty(self) -> bool"},
	 { "VectorString_size", _wrap_VectorString_size, METH_O, "VectorString_size(self) -> std::vector< std::string >::size_type"},
	 { "VectorString_swap", _wrap_VectorString_swap, METH_VARARGS, "\n"
		"VectorString_swap(self, v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v: std::vector< std::string > &\n"
		"\n"
		""},
	 { "VectorString_begin", _wrap_VectorString_begin, METH_O, "VectorString_begin(self) -> std::vector< std::string >::iterator"},
	 { "VectorString_end", _wrap_VectorString_end, METH_O, "VectorString_end(self) -> std::vector< std::string >::iterator"},
	 { "VectorString_rbegin", _wrap_VectorString_rbegin, METH_O, "VectorString_rbegin(self) -> std::vector< std::string >::reverse_iterator"},
	 { "VectorString_rend", _wrap_VectorString_rend, METH_O, "VectorString_rend(self) -> std::vector< std::string >::reverse_iterator"},
	 { "VectorString_clear", _wrap_VectorString_clear, METH_O, "VectorString_clear(self)"},
	 { "VectorString_get_allocator", _wrap_VectorString_get_allocator, METH_O, "VectorString_get_allocator(self) -> std::vector< std::string >::allocator_type"},
	 { "VectorString_pop_back", _wrap_VectorString_pop_back, METH_O, "VectorString_pop_back(self)"},
	 { "VectorString_erase", _wrap_VectorString_erase, METH_VARARGS, "\n"
		"VectorString_erase(self, pos) -> std::vector< std::string >::iterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pos: std::vector< std::string >::iterator\n"
		"\n"
		"VectorString_erase(self, first, last) -> std::vector< std::string >::iterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"first: std::vector< std::string >::iterator\n"
		"last: std::vector< std::string >::iterator\n"
		"\n"
		""},
	 { "new_VectorString", _wrap_new_VectorString, METH_VARARGS, "\n"
		"VectorString()\n"
		"VectorString(other)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"other: std::vector< std::string > const &\n"
		"\n"
		"VectorString(size)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"size: std::vector< std::string >::size_type\n"
		"\n"
		"new_VectorString(size, value) -> VectorString\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"size: std::vector< std::string >::size_type\n"
		"value: std::vector< std::string >::value_type const &\n"
		"\n"
		""},
	 { "VectorString_push_back", _wrap_VectorString_push_back, METH_VARARGS, "\n"
		"VectorString_push_back(self, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::vector< std::string >::value_type const &\n"
		"\n"
		""},
	 { "VectorString_front", _wrap_VectorString_front, METH_O, "VectorString_front(self) -> std::vector< std::string >::value_type const &"},
	 { "VectorString_back", _wrap_VectorString_back, METH_O, "VectorString_back(self) -> std::vector< std::string >::value_type const &"},
	 { "VectorString_assign", _wrap_VectorString_assign, METH_VARARGS, "\n"
		"VectorString_assign(self, n, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: std::vector< std::string >::size_type\n"
		"x: std::vector< std::string >::value_type const &\n"
		"\n"
		""},
	 { "VectorString_resize", _wrap_VectorString_resize, METH_VARARGS, "\n"
		"VectorString_resize(self, new_size)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"new_size: std::vector< std::string >::size_type\n"
		"\n"
		"VectorString_resize(self, new_size, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"new_size: std::vector< std::string >::size_type\n"
		"x: std::vector< std::string >::value_type const &\n"
		"\n"
		""},
	 { "VectorString_insert", _wrap_VectorString_insert, METH_VARARGS, "\n"
		"VectorString_insert(self, pos, x) -> std::vector< std::string >::iterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pos: std::vector< std::string >::iterator\n"
		"x: std::vector< std::string >::value_type const &\n"
		"\n"
		"VectorString_insert(self, pos, n, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pos: std::vector< std::string >::iterator\n"
		"n: std::vector< std::string >::size_type\n"
		"x: std::vector< std::string >::value_type const &\n"
		"\n"
		""},
	 { "VectorString_reserve", _wrap_VectorString_reserve, METH_VARARGS, "\n"
		"VectorString_reserve(self, n)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: std::vector< std::string >::size_type\n"
		"\n"
		""},
	 { "VectorString_capacity", _wrap_VectorString_capacity, METH_O, "VectorString_capacity(self) -> std::vector< std::string >::size_type"},
	 { "delete_VectorString", _wrap_delete_VectorString, METH_O, "delete_VectorString(self)"},
	 { "VectorString_swigregister", VectorString_swigregister, METH_O, NULL},
	 { "VectorString_swiginit", VectorString_swiginit, METH_VARARGS, NULL},
	 { "new_IntArray", _wrap_new_IntArray, METH_O, "\n"
		"new_IntArray(nelements) -> IntArray\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nelements: size_t\n"
		"\n"
		""},
	 { "delete_IntArray", _wrap_delete_IntArray, METH_O, "delete_IntArray(self)"},
	 { "IntArray___getitem__", _wrap_IntArray___getitem__, METH_VARARGS, "\n"
		"IntArray___getitem__(self, index) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"index: size_t\n"
		"\n"
		""},
	 { "IntArray___setitem__", _wrap_IntArray___setitem__, METH_VARARGS, "\n"
		"IntArray___setitem__(self, index, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"index: size_t\n"
		"value: int\n"
		"\n"
		""},
	 { "IntArray_cast", _wrap_IntArray_cast, METH_O, "IntArray_cast(self) -> int *"},
	 { "IntArray_frompointer", _wrap_IntArray_frompointer, METH_O, "\n"
		"IntArray_frompointer(t) -> IntArray\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"t: int *\n"
		"\n"
		""},
	 { "IntArray_swigregister", IntArray_swigregister, METH_O, NULL},
	 { "IntArray_swiginit", IntArray_swiginit, METH_VARARGS, NULL},
	 { "SessionIDSet_iterator", _wrap_SessionIDSet_iterator, METH_O, "SessionIDSet_iterator(self) -> SwigPyIterator"},
	 { "SessionIDSet___nonzero__", _wrap_SessionIDSet___nonzero__, METH_O, "SessionIDSet___nonzero__(self) -> bool"},
	 { "SessionIDSet___bool__", _wrap_SessionIDSet___bool__, METH_O, "SessionIDSet___bool__(self) -> bool"},
	 { "SessionIDSet___len__", _wrap_SessionIDSet___len__, METH_O, "SessionIDSet___len__(self) -> std::set< FIX::SessionID >::size_type"},
	 { "SessionIDSet_append", _wrap_SessionIDSet_append, METH_VARARGS, "\n"
		"SessionIDSet_append(self, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::value_type\n"
		"\n"
		""},
	 { "SessionIDSet___contains__", _wrap_SessionIDSet___contains__, METH_VARARGS, "\n"
		"SessionIDSet___contains__(self, x) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::value_type\n"
		"\n"
		""},
	 { "SessionIDSet___getitem__", _wrap_SessionIDSet___getitem__, METH_VARARGS, "\n"
		"SessionIDSet___getitem__(self, i) -> SessionID\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::set< FIX::SessionID >::difference_type\n"
		"\n"
		""},
	 { "SessionIDSet_add", _wrap_SessionIDSet_add, METH_VARARGS, "\n"
		"SessionIDSet_add(self, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::value_type\n"
		"\n"
		""},
	 { "SessionIDSet_discard", _wrap_SessionIDSet_discard, METH_VARARGS, "\n"
		"SessionIDSet_discard(self, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::value_type\n"
		"\n"
		""},
	 { "new_SessionIDSet", _wrap_new_SessionIDSet, METH_VARARGS, "\n"
		"SessionIDSet(other)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"other: std::less< FIX::SessionID > const &\n"
		"\n"
		"SessionIDSet()\n"
		"new_SessionIDSet(other) -> SessionIDSet\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"other: std::set< FIX::SessionID > const &\n"
		"\n"
		""},
	 { "SessionIDSet_empty", _wrap_SessionIDSet_empty, METH_O, "SessionIDSet_empty(self) -> bool"},
	 { "SessionIDSet_size", _wrap_SessionIDSet_size, METH_O, "SessionIDSet_size(self) -> std::set< FIX::SessionID >::size_type"},
	 { "SessionIDSet_clear", _wrap_SessionIDSet_clear, METH_O, "SessionIDSet_clear(self)"},
	 { "SessionIDSet_swap", _wrap_SessionIDSet_swap, METH_VARARGS, "\n"
		"SessionIDSet_swap(self, v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v: std::set< FIX::SessionID > &\n"
		"\n"
		""},
	 { "SessionIDSet_count", _wrap_SessionIDSet_count, METH_VARARGS, "\n"
		"SessionIDSet_count(self, x) -> std::set< FIX::SessionID >::size_type\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::key_type const &\n"
		"\n"
		""},
	 { "SessionIDSet_begin", _wrap_SessionIDSet_begin, METH_O, "SessionIDSet_begin(self) -> std::set< FIX::SessionID >::iterator"},
	 { "SessionIDSet_end", _wrap_SessionIDSet_end, METH_O, "SessionIDSet_end(self) -> std::set< FIX::SessionID >::iterator"},
	 { "SessionIDSet_rbegin", _wrap_SessionIDSet_rbegin, METH_O, "SessionIDSet_rbegin(self) -> std::set< FIX::SessionID >::reverse_iterator"},
	 { "SessionIDSet_rend", _wrap_SessionIDSet_rend, METH_O, "SessionIDSet_rend(self) -> std::set< FIX::SessionID >::reverse_iterator"},
	 { "SessionIDSet_erase", _wrap_SessionIDSet_erase, METH_VARARGS, "\n"
		"SessionIDSet_erase(self, x) -> std::set< FIX::SessionID >::size_type\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::key_type const &\n"
		"\n"
		"SessionIDSet_erase(self, pos)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pos: std::set< FIX::SessionID >::iterator\n"
		"\n"
		"SessionIDSet_erase(self, first, last)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"first: std::set< FIX::SessionID >::iterator\n"
		"last: std::set< FIX::SessionID >::iterator\n"
		"\n"
		""},
	 { "SessionIDSet_find", _wrap_SessionIDSet_find, METH_VARARGS, "\n"
		"SessionIDSet_find(self, x) -> std::set< FIX::SessionID >::iterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::key_type const &\n"
		"\n"
		""},
	 { "SessionIDSet_lower_bound", _wrap_SessionIDSet_lower_bound, METH_VARARGS, "\n"
		"SessionIDSet_lower_bound(self, x) -> std::set< FIX::SessionID >::iterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::key_type const &\n"
		"\n"
		""},
	 { "SessionIDSet_upper_bound", _wrap_SessionIDSet_upper_bound, METH_VARARGS, "\n"
		"SessionIDSet_upper_bound(self, x) -> std::set< FIX::SessionID >::iterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::key_type const &\n"
		"\n"
		""},
	 { "SessionIDSet_equal_range", _wrap_SessionIDSet_equal_range, METH_VARARGS, "\n"
		"SessionIDSet_equal_range(self, x) -> std::pair< std::set< FIX::SessionID >::iterator,std::set< FIX::SessionID >::iterator >\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::key_type const &\n"
		"\n"
		""},
	 { "SessionIDSet_insert", _wrap_SessionIDSet_insert, METH_VARARGS, "\n"
		"SessionIDSet_insert(self, __x) -> std::pair< std::set< FIX::SessionID >::iterator,bool >\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"__x: std::set< FIX::SessionID >::value_type const &\n"
		"\n"
		""},
	 { "delete_SessionIDSet", _wrap_delete_SessionIDSet, METH_O, "delete_SessionIDSet(self)"},
	 { "SessionIDSet_swigregister", SessionIDSet_swigregister, METH_O, NULL},
	 { "SessionIDSet_swiginit", SessionIDSet_swiginit, METH_VARARGS, NULL},
	 { "new_FIXException", _wrap_new_FIXException, METH_VARARGS, "\n"
		"new_FIXException(type, detail) -> FIXException\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type: std::string const &\n"
		"detail: std::string const &\n"
		"\n"
		""},
	 { "delete_FIXException", _wrap_delete_FIXException, METH_O, "delete_FIXException(self)"},
	 { "FIXException_type_set", _wrap_FIXException_type_set, METH_VARARGS, "\n"
		"FIXException_type_set(self, type)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type: std::string const &\n"
		"\n"
		""},
	 { "FIXException_type_get", _wrap_FIXException_type_get, METH_O, "FIXException_type_get(self) -> std::string const &"},
	 { "FIXException_detail_set", _wrap_FIXException_detail_set, METH_VARARGS, "\n"
		"FIXException_detail_set(self, detail)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"detail: std::string const &\n"
		"\n"
		""},
	 { "FIXException_detail_get", _wrap_FIXException_detail_get, METH_O, "FIXException_detail_get(self) -> std::string const &"},
	 { "FIXException___str__", _wrap_FIXException___str__, METH_O, "FIXException___str__(self) -> std::string"},
	 { "FIXException_swigregister", FIXException_swigregister, METH_O, NULL},
	 { "FIXException_swiginit", FIXException_swiginit, METH_VARARGS, NULL},
	 { "new_DataDictionaryNotFound", _wrap_new_DataDictionaryNotFound, METH_VARARGS, "\n"
		"DataDictionaryNotFound(version, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"version: std::string const &\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_DataDictionaryNotFound", _wrap_delete_DataDictionaryNotFound, METH_O, "delete_DataDictionaryNotFound(self)"},
	 { "DataDictionaryNotFound_version_set", _wrap_DataDictionaryNotFound_version_set, METH_VARARGS, "\n"
		"DataDictionaryNotFound_version_set(self, version)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"version: std::string const &\n"
		"\n"
		""},
	 { "DataDictionaryNotFound_version_get", _wrap_DataDictionaryNotFound_version_get, METH_O, "DataDictionaryNotFound_version_get(self) -> std::string const &"},
	 { "DataDictionaryNotFound_swigregister", DataDictionaryNotFound_swigregister, METH_O, NULL},
	 { "DataDictionaryNotFound_swiginit", DataDictionaryNotFound_swiginit, METH_VARARGS, NULL},
	 { "new_FieldNotFound", _wrap_new_FieldNotFound, METH_VARARGS, "\n"
		"FieldNotFound(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "FieldNotFound_field_set", _wrap_FieldNotFound_field_set, METH_VARARGS, "\n"
		"FieldNotFound_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "FieldNotFound_field_get", _wrap_FieldNotFound_field_get, METH_O, "FieldNotFound_field_get(self) -> int"},
	 { "delete_FieldNotFound", _wrap_delete_FieldNotFound, METH_O, "delete_FieldNotFound(self)"},
	 { "FieldNotFound_swigregister", FieldNotFound_swigregister, METH_O, NULL},
	 { "FieldNotFound_swiginit", FieldNotFound_swiginit, METH_VARARGS, NULL},
	 { "new_FieldConvertError", _wrap_new_FieldConvertError, METH_VARARGS, "\n"
		"FieldConvertError(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_FieldConvertError", _wrap_delete_FieldConvertError, METH_O, "delete_FieldConvertError(self)"},
	 { "FieldConvertError_swigregister", FieldConvertError_swigregister, METH_O, NULL},
	 { "FieldConvertError_swiginit", FieldConvertError_swiginit, METH_VARARGS, NULL},
	 { "new_MessageParseError", _wrap_new_MessageParseError, METH_VARARGS, "\n"
		"MessageParseError(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_MessageParseError", _wrap_delete_MessageParseError, METH_O, "delete_MessageParseError(self)"},
	 { "MessageParseError_swigregister", MessageParseError_swigregister, METH_O, NULL},
	 { "MessageParseError_swiginit", MessageParseError_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidMessage", _wrap_new_InvalidMessage, METH_VARARGS, "\n"
		"InvalidMessage(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_InvalidMessage", _wrap_delete_InvalidMessage, METH_O, "delete_InvalidMessage(self)"},
	 { "InvalidMessage_swigregister", InvalidMessage_swigregister, METH_O, NULL},
	 { "InvalidMessage_swiginit", InvalidMessage_swiginit, METH_VARARGS, NULL},
	 { "new_ConfigError", _wrap_new_ConfigError, METH_VARARGS, "\n"
		"ConfigError(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_ConfigError", _wrap_delete_ConfigError, METH_O, "delete_ConfigError(self)"},
	 { "ConfigError_swigregister", ConfigError_swigregister, METH_O, NULL},
	 { "ConfigError_swiginit", ConfigError_swiginit, METH_VARARGS, NULL},
	 { "new_RuntimeError", _wrap_new_RuntimeError, METH_VARARGS, "\n"
		"RuntimeError(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_RuntimeError", _wrap_delete_RuntimeError, METH_O, "delete_RuntimeError(self)"},
	 { "RuntimeError_swigregister", RuntimeError_swigregister, METH_O, NULL},
	 { "RuntimeError_swiginit", RuntimeError_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidTagNumber", _wrap_new_InvalidTagNumber, METH_VARARGS, "\n"
		"InvalidTagNumber(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "InvalidTagNumber_field_set", _wrap_InvalidTagNumber_field_set, METH_VARARGS, "\n"
		"InvalidTagNumber_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "InvalidTagNumber_field_get", _wrap_InvalidTagNumber_field_get, METH_O, "InvalidTagNumber_field_get(self) -> int"},
	 { "delete_InvalidTagNumber", _wrap_delete_InvalidTagNumber, METH_O, "delete_InvalidTagNumber(self)"},
	 { "InvalidTagNumber_swigregister", InvalidTagNumber_swigregister, METH_O, NULL},
	 { "InvalidTagNumber_swiginit", InvalidTagNumber_swiginit, METH_VARARGS, NULL},
	 { "new_RequiredTagMissing", _wrap_new_RequiredTagMissing, METH_VARARGS, "\n"
		"RequiredTagMissing(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "RequiredTagMissing_field_set", _wrap_RequiredTagMissing_field_set, METH_VARARGS, "\n"
		"RequiredTagMissing_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "RequiredTagMissing_field_get", _wrap_RequiredTagMissing_field_get, METH_O, "RequiredTagMissing_field_get(self) -> int"},
	 { "delete_RequiredTagMissing", _wrap_delete_RequiredTagMissing, METH_O, "delete_RequiredTagMissing(self)"},
	 { "RequiredTagMissing_swigregister", RequiredTagMissing_swigregister, METH_O, NULL},
	 { "RequiredTagMissing_swiginit", RequiredTagMissing_swiginit, METH_VARARGS, NULL},
	 { "new_TagNotDefinedForMessage", _wrap_new_TagNotDefinedForMessage, METH_VARARGS, "\n"
		"TagNotDefinedForMessage(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "TagNotDefinedForMessage_field_set", _wrap_TagNotDefinedForMessage_field_set, METH_VARARGS, "\n"
		"TagNotDefinedForMessage_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "TagNotDefinedForMessage_field_get", _wrap_TagNotDefinedForMessage_field_get, METH_O, "TagNotDefinedForMessage_field_get(self) -> int"},
	 { "delete_TagNotDefinedForMessage", _wrap_delete_TagNotDefinedForMessage, METH_O, "delete_TagNotDefinedForMessage(self)"},
	 { "TagNotDefinedForMessage_swigregister", TagNotDefinedForMessage_swigregister, METH_O, NULL},
	 { "TagNotDefinedForMessage_swiginit", TagNotDefinedForMessage_swiginit, METH_VARARGS, NULL},
	 { "new_NoTagValue", _wrap_new_NoTagValue, METH_VARARGS, "\n"
		"NoTagValue(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "NoTagValue_field_set", _wrap_NoTagValue_field_set, METH_VARARGS, "\n"
		"NoTagValue_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "NoTagValue_field_get", _wrap_NoTagValue_field_get, METH_O, "NoTagValue_field_get(self) -> int"},
	 { "delete_NoTagValue", _wrap_delete_NoTagValue, METH_O, "delete_NoTagValue(self)"},
	 { "NoTagValue_swigregister", NoTagValue_swigregister, METH_O, NULL},
	 { "NoTagValue_swiginit", NoTagValue_swiginit, METH_VARARGS, NULL},
	 { "new_IncorrectTagValue", _wrap_new_IncorrectTagValue, METH_VARARGS, "\n"
		"IncorrectTagValue(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "IncorrectTagValue_field_set", _wrap_IncorrectTagValue_field_set, METH_VARARGS, "\n"
		"IncorrectTagValue_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "IncorrectTagValue_field_get", _wrap_IncorrectTagValue_field_get, METH_O, "IncorrectTagValue_field_get(self) -> int"},
	 { "delete_IncorrectTagValue", _wrap_delete_IncorrectTagValue, METH_O, "delete_IncorrectTagValue(self)"},
	 { "IncorrectTagValue_swigregister", IncorrectTagValue_swigregister, METH_O, NULL},
	 { "IncorrectTagValue_swiginit", IncorrectTagValue_swiginit, METH_VARARGS, NULL},
	 { "new_IncorrectDataFormat", _wrap_new_IncorrectDataFormat, METH_VARARGS, "\n"
		"IncorrectDataFormat(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "IncorrectDataFormat_field_set", _wrap_IncorrectDataFormat_field_set, METH_VARARGS, "\n"
		"IncorrectDataFormat_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "IncorrectDataFormat_field_get", _wrap_IncorrectDataFormat_field_get, METH_O, "IncorrectDataFormat_field_get(self) -> int"},
	 { "delete_IncorrectDataFormat", _wrap_delete_IncorrectDataFormat, METH_O, "delete_IncorrectDataFormat(self)"},
	 { "IncorrectDataFormat_swigregister", IncorrectDataFormat_swigregister, METH_O, NULL},
	 { "IncorrectDataFormat_swiginit", IncorrectDataFormat_swiginit, METH_VARARGS, NULL},
	 { "new_IncorrectMessageStructure", _wrap_new_IncorrectMessageStructure, METH_VARARGS, "\n"
		"IncorrectMessageStructure(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_IncorrectMessageStructure", _wrap_delete_IncorrectMessageStructure, METH_O, "delete_IncorrectMessageStructure(self)"},
	 { "IncorrectMessageStructure_swigregister", IncorrectMessageStructure_swigregister, METH_O, NULL},
	 { "IncorrectMessageStructure_swiginit", IncorrectMessageStructure_swiginit, METH_VARARGS, NULL},
	 { "new_DuplicateFieldNumber", _wrap_new_DuplicateFieldNumber, METH_VARARGS, "\n"
		"DuplicateFieldNumber(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_DuplicateFieldNumber", _wrap_delete_DuplicateFieldNumber, METH_O, "delete_DuplicateFieldNumber(self)"},
	 { "DuplicateFieldNumber_swigregister", DuplicateFieldNumber_swigregister, METH_O, NULL},
	 { "DuplicateFieldNumber_swiginit", DuplicateFieldNumber_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidMessageType", _wrap_new_InvalidMessageType, METH_VARARGS, "\n"
		"InvalidMessageType(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_InvalidMessageType", _wrap_delete_InvalidMessageType, METH_O, "delete_InvalidMessageType(self)"},
	 { "InvalidMessageType_swigregister", InvalidMessageType_swigregister, METH_O, NULL},
	 { "InvalidMessageType_swiginit", InvalidMessageType_swiginit, METH_VARARGS, NULL},
	 { "new_UnsupportedMessageType", _wrap_new_UnsupportedMessageType, METH_VARARGS, "\n"
		"UnsupportedMessageType(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_UnsupportedMessageType", _wrap_delete_UnsupportedMessageType, METH_O, "delete_UnsupportedMessageType(self)"},
	 { "UnsupportedMessageType_swigregister", UnsupportedMessageType_swigregister, METH_O, NULL},
	 { "UnsupportedMessageType_swiginit", UnsupportedMessageType_swiginit, METH_VARARGS, NULL},
	 { "new_UnsupportedVersion", _wrap_new_UnsupportedVersion, METH_VARARGS, "\n"
		"UnsupportedVersion(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_UnsupportedVersion", _wrap_delete_UnsupportedVersion, METH_O, "delete_UnsupportedVersion(self)"},
	 { "UnsupportedVersion_swigregister", UnsupportedVersion_swigregister, METH_O, NULL},
	 { "UnsupportedVersion_swiginit", UnsupportedVersion_swiginit, METH_VARARGS, NULL},
	 { "new_TagOutOfOrder", _wrap_new_TagOutOfOrder, METH_VARARGS, "\n"
		"TagOutOfOrder(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "TagOutOfOrder_field_set", _wrap_TagOutOfOrder_field_set, METH_VARARGS, "\n"
		"TagOutOfOrder_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "TagOutOfOrder_field_get", _wrap_TagOutOfOrder_field_get, METH_O, "TagOutOfOrder_field_get(self) -> int"},
	 { "delete_TagOutOfOrder", _wrap_delete_TagOutOfOrder, METH_O, "delete_TagOutOfOrder(self)"},
	 { "TagOutOfOrder_swigregister", TagOutOfOrder_swigregister, METH_O, NULL},
	 { "TagOutOfOrder_swiginit", TagOutOfOrder_swiginit, METH_VARARGS, NULL},
	 { "new_RepeatedTag", _wrap_new_RepeatedTag, METH_VARARGS, "\n"
		"RepeatedTag(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "RepeatedTag_field_set", _wrap_RepeatedTag_field_set, METH_VARARGS, "\n"
		"RepeatedTag_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "RepeatedTag_field_get", _wrap_RepeatedTag_field_get, METH_O, "RepeatedTag_field_get(self) -> int"},
	 { "delete_RepeatedTag", _wrap_delete_RepeatedTag, METH_O, "delete_RepeatedTag(self)"},
	 { "RepeatedTag_swigregister", RepeatedTag_swigregister, METH_O, NULL},
	 { "RepeatedTag_swiginit", RepeatedTag_swiginit, METH_VARARGS, NULL},
	 { "new_RepeatingGroupCountMismatch", _wrap_new_RepeatingGroupCountMismatch, METH_VARARGS, "\n"
		"RepeatingGroupCountMismatch(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "RepeatingGroupCountMismatch_field_set", _wrap_RepeatingGroupCountMismatch_field_set, METH_VARARGS, "\n"
		"RepeatingGroupCountMismatch_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "RepeatingGroupCountMismatch_field_get", _wrap_RepeatingGroupCountMismatch_field_get, METH_O, "RepeatingGroupCountMismatch_field_get(self) -> int"},
	 { "delete_RepeatingGroupCountMismatch", _wrap_delete_RepeatingGroupCountMismatch, METH_O, "delete_RepeatingGroupCountMismatch(self)"},
	 { "RepeatingGroupCountMismatch_swigregister", RepeatingGroupCountMismatch_swigregister, METH_O, NULL},
	 { "RepeatingGroupCountMismatch_swiginit", RepeatingGroupCountMismatch_swiginit, METH_VARARGS, NULL},
	 { "new_DoNotSend", _wrap_new_DoNotSend, METH_VARARGS, "\n"
		"DoNotSend(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_DoNotSend", _wrap_delete_DoNotSend, METH_O, "delete_DoNotSend(self)"},
	 { "DoNotSend_swigregister", DoNotSend_swigregister, METH_O, NULL},
	 { "DoNotSend_swiginit", DoNotSend_swiginit, METH_VARARGS, NULL},
	 { "new_RejectLogon", _wrap_new_RejectLogon, METH_VARARGS, "\n"
		"RejectLogon(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_RejectLogon", _wrap_delete_RejectLogon, METH_O, "delete_RejectLogon(self)"},
	 { "RejectLogon_swigregister", RejectLogon_swigregister, METH_O, NULL},
	 { "RejectLogon_swiginit", RejectLogon_swiginit, METH_VARARGS, NULL},
	 { "new_SessionNotFound", _wrap_new_SessionNotFound, METH_VARARGS, "\n"
		"SessionNotFound(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_SessionNotFound", _wrap_delete_SessionNotFound, METH_O, "delete_SessionNotFound(self)"},
	 { "SessionNotFound_swigregister", SessionNotFound_swigregister, METH_O, NULL},
	 { "SessionNotFound_swiginit", SessionNotFound_swiginit, METH_VARARGS, NULL},
	 { "new_IOException", _wrap_new_IOException, METH_VARARGS, "\n"
		"IOException(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_IOException", _wrap_delete_IOException, METH_O, "delete_IOException(self)"},
	 { "IOException_swigregister", IOException_swigregister, METH_O, NULL},
	 { "IOException_swiginit", IOException_swiginit, METH_VARARGS, NULL},
	 { "new_SocketException", _wrap_new_SocketException, METH_VARARGS, "\n"
		"SocketException()\n"
		"new_SocketException(what) -> SocketException\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "SocketException_errorToWhat", _wrap_SocketException_errorToWhat, METH_NOARGS, "SocketException_errorToWhat() -> std::string"},
	 { "delete_SocketException", _wrap_delete_SocketException, METH_O, "delete_SocketException(self)"},
	 { "SocketException_swigregister", SocketException_swigregister, METH_O, NULL},
	 { "SocketException_swiginit", SocketException_swiginit, METH_VARARGS, NULL},
	 { "new_SocketSendFailed", _wrap_new_SocketSendFailed, METH_VARARGS, "\n"
		"SocketSendFailed()\n"
		"new_SocketSendFailed(what) -> SocketSendFailed\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_SocketSendFailed", _wrap_delete_SocketSendFailed, METH_O, "delete_SocketSendFailed(self)"},
	 { "SocketSendFailed_swigregister", SocketSendFailed_swigregister, METH_O, NULL},
	 { "SocketSendFailed_swiginit", SocketSendFailed_swiginit, METH_VARARGS, NULL},
	 { "new_SocketRecvFailed", _wrap_new_SocketRecvFailed, METH_VARARGS, "\n"
		"SocketRecvFailed(size)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"size: ssize_t\n"
		"\n"
		"new_SocketRecvFailed(what) -> SocketRecvFailed\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_SocketRecvFailed", _wrap_delete_SocketRecvFailed, METH_O, "delete_SocketRecvFailed(self)"},
	 { "SocketRecvFailed_swigregister", SocketRecvFailed_swigregister, METH_O, NULL},
	 { "SocketRecvFailed_swiginit", SocketRecvFailed_swiginit, METH_VARARGS, NULL},
	 { "new_SocketCloseFailed", _wrap_new_SocketCloseFailed, METH_VARARGS, "\n"
		"SocketCloseFailed()\n"
		"new_SocketCloseFailed(what) -> SocketCloseFailed\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_SocketCloseFailed", _wrap_delete_SocketCloseFailed, METH_O, "delete_SocketCloseFailed(self)"},
	 { "SocketCloseFailed_swigregister", SocketCloseFailed_swigregister, METH_O, NULL},
	 { "SocketCloseFailed_swiginit", SocketCloseFailed_swiginit, METH_VARARGS, NULL},
	 { "DateTime_m_date_set", _wrap_DateTime_m_date_set, METH_VARARGS, "\n"
		"DateTime_m_date_set(self, m_date)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"m_date: int\n"
		"\n"
		""},
	 { "DateTime_m_date_get", _wrap_DateTime_m_date_get, METH_O, "DateTime_m_date_get(self) -> int"},
	 { "DateTime_m_time_set", _wrap_DateTime_m_time_set, METH_VARARGS, "\n"
		"DateTime_m_time_set(self, m_time)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"m_time: int64_t\n"
		"\n"
		""},
	 { "DateTime_m_time_get", _wrap_DateTime_m_time_get, METH_O, "DateTime_m_time_get(self) -> int64_t"},
	 { "new_DateTime", _wrap_new_DateTime, METH_VARARGS, "\n"
		"DateTime()\n"
		"DateTime(date, time)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"date: int\n"
		"time: int64_t\n"
		"\n"
		"DateTime(year, month, day, hour, minute, second, millis)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"year: int\n"
		"month: int\n"
		"day: int\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millis: int\n"
		"\n"
		"new_DateTime(year, month, day, hour, minute, second, fraction, precision) -> DateTime\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"year: int\n"
		"month: int\n"
		"day: int\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "delete_DateTime", _wrap_delete_DateTime, METH_O, "delete_DateTime(self)"},
	 { "DateTime_getYear", _wrap_DateTime_getYear, METH_O, "DateTime_getYear(self) -> int"},
	 { "DateTime_getMonth", _wrap_DateTime_getMonth, METH_O, "DateTime_getMonth(self) -> int"},
	 { "DateTime_getDay", _wrap_DateTime_getDay, METH_O, "DateTime_getDay(self) -> int"},
	 { "DateTime_getDate", _wrap_DateTime_getDate, METH_O, "DateTime_getDate(self) -> int"},
	 { "DateTime_getJulianDate", _wrap_DateTime_getJulianDate, METH_O, "DateTime_getJulianDate(self) -> int"},
	 { "DateTime_getHour", _wrap_DateTime_getHour, METH_O, "DateTime_getHour(self) -> int"},
	 { "DateTime_getMinute", _wrap_DateTime_getMinute, METH_O, "DateTime_getMinute(self) -> int"},
	 { "DateTime_getSecond", _wrap_DateTime_getSecond, METH_O, "DateTime_getSecond(self) -> int"},
	 { "DateTime_getMillisecond", _wrap_DateTime_getMillisecond, METH_O, "DateTime_getMillisecond(self) -> int"},
	 { "DateTime_getMicrosecond", _wrap_DateTime_getMicrosecond, METH_O, "DateTime_getMicrosecond(self) -> int"},
	 { "DateTime_getNanosecond", _wrap_DateTime_getNanosecond, METH_O, "DateTime_getNanosecond(self) -> unsigned int"},
	 { "DateTime_getFraction", _wrap_DateTime_getFraction, METH_VARARGS, "\n"
		"DateTime_getFraction(self, precision) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"precision: int\n"
		"\n"
		""},
	 { "DateTime_getWeekDay", _wrap_DateTime_getWeekDay, METH_O, "DateTime_getWeekDay(self) -> int"},
	 { "DateTime_getTimeT", _wrap_DateTime_getTimeT, METH_O, "DateTime_getTimeT(self) -> time_t"},
	 { "DateTime_getTmUtc", _wrap_DateTime_getTmUtc, METH_O, "DateTime_getTmUtc(self) -> tm"},
	 { "DateTime_setYMD", _wrap_DateTime_setYMD, METH_VARARGS, "\n"
		"DateTime_setYMD(self, year, month, day)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"year: int\n"
		"month: int\n"
		"day: int\n"
		"\n"
		""},
	 { "DateTime_setHMS", _wrap_DateTime_setHMS, METH_VARARGS, "\n"
		"DateTime_setHMS(self, hour, minute, second, millis)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millis: int\n"
		"\n"
		"DateTime_setHMS(self, hour, minute, second, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "DateTime_setHour", _wrap_DateTime_setHour, METH_VARARGS, "\n"
		"DateTime_setHour(self, hour)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"\n"
		""},
	 { "DateTime_setMinute", _wrap_DateTime_setMinute, METH_VARARGS, "\n"
		"DateTime_setMinute(self, min)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"min: int\n"
		"\n"
		""},
	 { "DateTime_setSecond", _wrap_DateTime_setSecond, METH_VARARGS, "\n"
		"DateTime_setSecond(self, sec)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sec: int\n"
		"\n"
		""},
	 { "DateTime_setMillisecond", _wrap_DateTime_setMillisecond, METH_VARARGS, "\n"
		"DateTime_setMillisecond(self, millis)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"millis: int\n"
		"\n"
		""},
	 { "DateTime_setMicrosecond", _wrap_DateTime_setMicrosecond, METH_VARARGS, "\n"
		"DateTime_setMicrosecond(self, micros)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"micros: int\n"
		"\n"
		""},
	 { "DateTime_setNanosecond", _wrap_DateTime_setNanosecond, METH_VARARGS, "\n"
		"DateTime_setNanosecond(self, nanos)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nanos: int\n"
		"\n"
		""},
	 { "DateTime_setFraction", _wrap_DateTime_setFraction, METH_VARARGS, "\n"
		"DateTime_setFraction(self, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "DateTime_clearDate", _wrap_DateTime_clearDate, METH_O, "DateTime_clearDate(self)"},
	 { "DateTime_clearTime", _wrap_DateTime_clearTime, METH_O, "DateTime_clearTime(self)"},
	 { "DateTime_set", _wrap_DateTime_set, METH_VARARGS, "\n"
		"DateTime_set(self, date, time)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"date: int\n"
		"time: int64_t\n"
		"\n"
		"DateTime_set(self, other)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"other: FIX::DateTime const &\n"
		"\n"
		""},
	 { "DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, "\n"
		"DateTime___iadd__(self, seconds)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"seconds: int\n"
		"\n"
		""},
	 { "DateTime_convertToNanos", _wrap_DateTime_convertToNanos, METH_VARARGS, "\n"
		"DateTime_convertToNanos(fraction, precision) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "DateTime_makeHMS", _wrap_DateTime_makeHMS, METH_VARARGS, "\n"
		"DateTime_makeHMS(hour, minute, second, nanos) -> int64_t\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"nanos: int\n"
		"\n"
		""},
	 { "DateTime_nowUtc", _wrap_DateTime_nowUtc, METH_NOARGS, "DateTime_nowUtc() -> DateTime"},
	 { "DateTime_nowLocal", _wrap_DateTime_nowLocal, METH_NOARGS, "DateTime_nowLocal() -> DateTime"},
	 { "DateTime_fromUtcTimeT", _wrap_DateTime_fromUtcTimeT, METH_VARARGS, "\n"
		"DateTime_fromUtcTimeT(t, millis=0) -> DateTime\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"t: time_t\n"
		"millis: int\n"
		"\n"
		"DateTime_fromUtcTimeT(t, fraction, precision) -> DateTime\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"t: time_t\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "DateTime_fromLocalTimeT", _wrap_DateTime_fromLocalTimeT, METH_VARARGS, "\n"
		"DateTime_fromLocalTimeT(t, millis=0) -> DateTime\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"t: time_t\n"
		"millis: int\n"
		"\n"
		"DateTime_fromLocalTimeT(t, fraction, precision) -> DateTime\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"t: time_t\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "DateTime_fromTm", _wrap_DateTime_fromTm, METH_VARARGS, "\n"
		"DateTime_fromTm(tm, millis=0) -> DateTime\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tm: tm const &\n"
		"millis: int\n"
		"\n"
		"DateTime_fromTm(tm, fraction, precision) -> DateTime\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tm: tm const &\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "DateTime_julianDate", _wrap_DateTime_julianDate, METH_VARARGS, "\n"
		"DateTime_julianDate(year, month, day) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"year: int\n"
		"month: int\n"
		"day: int\n"
		"\n"
		""},
	 { "DateTime_swigregister", DateTime_swigregister, METH_O, NULL},
	 { "DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
	 { "__sub__", _wrap___sub__, METH_VARARGS, "\n"
		"__sub__(lhs, rhs) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::DateTime const &\n"
		"rhs: FIX::DateTime const &\n"
		"\n"
		""},
	 { "UtcTimeStamp_now", _wrap_UtcTimeStamp_now, METH_NOARGS, "UtcTimeStamp_now() -> UtcTimeStamp"},
	 { "new_UtcTimeStamp", _wrap_new_UtcTimeStamp, METH_VARARGS, "\n"
		"UtcTimeStamp()\n"
		"UtcTimeStamp(dateTime)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dateTime: FIX::DateTime\n"
		"\n"
		"UtcTimeStamp(hour, minute, second, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millisecond: int\n"
		"\n"
		"UtcTimeStamp(hour, minute, second, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"UtcTimeStamp(hour, minute, second, date, month, year)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"\n"
		"UtcTimeStamp(hour, minute, second, millisecond, date, month, year)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millisecond: int\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"\n"
		"UtcTimeStamp(hour, minute, second, fraction, date, month, year, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"precision: int\n"
		"\n"
		"UtcTimeStamp(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"millisecond: int\n"
		"\n"
		"UtcTimeStamp(time, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"UtcTimeStamp(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"millisecond: int\n"
		"\n"
		"new_UtcTimeStamp(time, fraction, precision) -> UtcTimeStamp\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "UtcTimeStamp_setCurrent", _wrap_UtcTimeStamp_setCurrent, METH_O, "UtcTimeStamp_setCurrent(self)"},
	 { "UtcTimeStamp_getDateTime", _wrap_UtcTimeStamp_getDateTime, METH_O, "UtcTimeStamp_getDateTime(self) -> PyObject *"},
	 { "delete_UtcTimeStamp", _wrap_delete_UtcTimeStamp, METH_O, "delete_UtcTimeStamp(self)"},
	 { "UtcTimeStamp_swigregister", UtcTimeStamp_swigregister, METH_O, NULL},
	 { "UtcTimeStamp_swiginit", UtcTimeStamp_swiginit, METH_VARARGS, NULL},
	 { "new_LocalTimeStamp", _wrap_new_LocalTimeStamp, METH_VARARGS, "\n"
		"LocalTimeStamp()\n"
		"LocalTimeStamp(hour, minute, second, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millisecond: int\n"
		"\n"
		"LocalTimeStamp(hour, minute, second, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"LocalTimeStamp(hour, minute, second, date, month, year)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"\n"
		"LocalTimeStamp(hour, minute, second, millisecond, date, month, year)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millisecond: int\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"\n"
		"LocalTimeStamp(hour, minute, second, fraction, date, month, year, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"precision: int\n"
		"\n"
		"LocalTimeStamp(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"millisecond: int\n"
		"\n"
		"LocalTimeStamp(time, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"LocalTimeStamp(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"millisecond: int\n"
		"\n"
		"new_LocalTimeStamp(time, fraction, precision) -> LocalTimeStamp\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "LocalTimeStamp_setCurrent", _wrap_LocalTimeStamp_setCurrent, METH_O, "LocalTimeStamp_setCurrent(self)"},
	 { "delete_LocalTimeStamp", _wrap_delete_LocalTimeStamp, METH_O, "delete_LocalTimeStamp(self)"},
	 { "LocalTimeStamp_swigregister", LocalTimeStamp_swigregister, METH_O, NULL},
	 { "LocalTimeStamp_swiginit", LocalTimeStamp_swiginit, METH_VARARGS, NULL},
	 { "new_UtcTimeOnly", _wrap_new_UtcTimeOnly, METH_VARARGS, "\n"
		"UtcTimeOnly()\n"
		"UtcTimeOnly(val)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"val: FIX::DateTime const &\n"
		"\n"
		"UtcTimeOnly(hour, minute, second, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millisecond: int\n"
		"\n"
		"UtcTimeOnly(hour, minute, second, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"UtcTimeOnly(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"millisecond: int\n"
		"\n"
		"UtcTimeOnly(time, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"UtcTimeOnly(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"millisecond: int\n"
		"\n"
		"new_UtcTimeOnly(time, fraction, precision) -> UtcTimeOnly\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "UtcTimeOnly_setCurrent", _wrap_UtcTimeOnly_setCurrent, METH_O, "UtcTimeOnly_setCurrent(self)"},
	 { "delete_UtcTimeOnly", _wrap_delete_UtcTimeOnly, METH_O, "delete_UtcTimeOnly(self)"},
	 { "UtcTimeOnly_swigregister", UtcTimeOnly_swigregister, METH_O, NULL},
	 { "UtcTimeOnly_swiginit", UtcTimeOnly_swiginit, METH_VARARGS, NULL},
	 { "new_LocalTimeOnly", _wrap_new_LocalTimeOnly, METH_VARARGS, "\n"
		"LocalTimeOnly()\n"
		"LocalTimeOnly(val)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"val: FIX::DateTime const &\n"
		"\n"
		"LocalTimeOnly(hour, minute, second, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millisecond: int\n"
		"\n"
		"LocalTimeOnly(hour, minute, second, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"LocalTimeOnly(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"millisecond: int\n"
		"\n"
		"LocalTimeOnly(time, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"LocalTimeOnly(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"millisecond: int\n"
		"\n"
		"new_LocalTimeOnly(time, fraction, precision) -> LocalTimeOnly\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "LocalTimeOnly_setCurrent", _wrap_LocalTimeOnly_setCurrent, METH_O, "LocalTimeOnly_setCurrent(self)"},
	 { "delete_LocalTimeOnly", _wrap_delete_LocalTimeOnly, METH_O, "delete_LocalTimeOnly(self)"},
	 { "LocalTimeOnly_swigregister", LocalTimeOnly_swigregister, METH_O, NULL},
	 { "LocalTimeOnly_swiginit", LocalTimeOnly_swiginit, METH_VARARGS, NULL},
	 { "new_UtcDate", _wrap_new_UtcDate, METH_VARARGS, "\n"
		"UtcDate()\n"
		"UtcDate(val)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"val: FIX::DateTime const &\n"
		"\n"
		"UtcDate(date, month, year)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"\n"
		"UtcDate(sec)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sec: int\n"
		"\n"
		"new_UtcDate(time) -> UtcDate\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"\n"
		""},
	 { "UtcDate_setCurrent", _wrap_UtcDate_setCurrent, METH_O, "UtcDate_setCurrent(self)"},
	 { "delete_UtcDate", _wrap_delete_UtcDate, METH_O, "delete_UtcDate(self)"},
	 { "UtcDate_swigregister", UtcDate_swigregister, METH_O, NULL},
	 { "UtcDate_swiginit", UtcDate_swiginit, METH_VARARGS, NULL},
	 { "new_LocalDate", _wrap_new_LocalDate, METH_VARARGS, "\n"
		"LocalDate()\n"
		"LocalDate(val)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"val: FIX::DateTime const &\n"
		"\n"
		"LocalDate(date, month, year)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"\n"
		"LocalDate(sec)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sec: int\n"
		"\n"
		"new_LocalDate(time) -> LocalDate\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"\n"
		""},
	 { "LocalDate_setCurrent", _wrap_LocalDate_setCurrent, METH_O, "LocalDate_setCurrent(self)"},
	 { "delete_LocalDate", _wrap_delete_LocalDate, METH_O, "delete_LocalDate(self)"},
	 { "LocalDate_swigregister", LocalDate_swigregister, METH_O, NULL},
	 { "LocalDate_swiginit", LocalDate_swiginit, METH_VARARGS, NULL},
	 { "delete_FieldBase", _wrap_delete_FieldBase, METH_O, "delete_FieldBase(self)"},
	 { "new_FieldBase", _wrap_new_FieldBase, METH_VARARGS, "\n"
		"FieldBase(tag, string)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"string: std::string const &\n"
		"\n"
		"new_FieldBase(rhs) -> FieldBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::FieldBase const &\n"
		"\n"
		""},
	 { "FieldBase_swap", _wrap_FieldBase_swap, METH_VARARGS, "\n"
		"FieldBase_swap(self, rhs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::FieldBase &\n"
		"\n"
		""},
	 { "FieldBase_setTag", _wrap_FieldBase_setTag, METH_VARARGS, "\n"
		"FieldBase_setTag(self, tag)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldBase_setField", _wrap_FieldBase_setField, METH_VARARGS, "\n"
		"FieldBase_setField(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "FieldBase_setString", _wrap_FieldBase_setString, METH_VARARGS, "\n"
		"FieldBase_setString(self, string)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"\n"
		""},
	 { "FieldBase_getTag", _wrap_FieldBase_getTag, METH_O, "FieldBase_getTag(self) -> int"},
	 { "FieldBase_getField", _wrap_FieldBase_getField, METH_O, "FieldBase_getField(self) -> int"},
	 { "FieldBase_getString", _wrap_FieldBase_getString, METH_O, "FieldBase_getString(self) -> std::string const &"},
	 { "FieldBase_getFixString", _wrap_FieldBase_getFixString, METH_O, "FieldBase_getFixString(self) -> std::string const &"},
	 { "FieldBase_getLength", _wrap_FieldBase_getLength, METH_O, "FieldBase_getLength(self) -> int"},
	 { "FieldBase_getTotal", _wrap_FieldBase_getTotal, METH_O, "FieldBase_getTotal(self) -> int"},
	 { "FieldBase___lt__", _wrap_FieldBase___lt__, METH_VARARGS, "\n"
		"FieldBase___lt__(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: FIX::FieldBase const &\n"
		"\n"
		""},
	 { "FieldBase___str__", _wrap_FieldBase___str__, METH_O, "FieldBase___str__(self) -> std::string"},
	 { "FieldBase_swigregister", FieldBase_swigregister, METH_O, NULL},
	 { "FieldBase_swiginit", FieldBase_swiginit, METH_VARARGS, NULL},
	 { "swap", _wrap_swap, METH_VARARGS, "\n"
		"swap(lhs, rhs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::FieldBase &\n"
		"rhs: FIX::FieldBase &\n"
		"\n"
		""},
	 { "new_StringField", _wrap_new_StringField, METH_VARARGS, "\n"
		"StringField(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: std::string const &\n"
		"\n"
		"new_StringField(field) -> StringField\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "StringField_setValue", _wrap_StringField_setValue, METH_VARARGS, "\n"
		"StringField_setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "StringField_getValue", _wrap_StringField_getValue, METH_O, "StringField_getValue(self) -> std::string const &"},
	 { "StringField___lt__", _wrap_StringField___lt__, METH_VARARGS, "\n"
		"StringField___lt__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::StringField const &\n"
		"\n"
		""},
	 { "StringField___gt__", _wrap_StringField___gt__, METH_VARARGS, "\n"
		"StringField___gt__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::StringField const &\n"
		"\n"
		""},
	 { "StringField___eq__", _wrap_StringField___eq__, METH_VARARGS, "\n"
		"StringField___eq__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::StringField const &\n"
		"\n"
		""},
	 { "StringField___ne__", _wrap_StringField___ne__, METH_VARARGS, "\n"
		"StringField___ne__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::StringField const &\n"
		"\n"
		""},
	 { "StringField___le__", _wrap_StringField___le__, METH_VARARGS, "\n"
		"StringField___le__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::StringField const &\n"
		"\n"
		""},
	 { "StringField___ge__", _wrap_StringField___ge__, METH_VARARGS, "\n"
		"StringField___ge__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::StringField const &\n"
		"\n"
		""},
	 { "__gt__", _wrap___gt__, METH_VARARGS, "\n"
		"__gt__(lhs, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::DateTime const &\n"
		"rhs: FIX::DateTime const &\n"
		"\n"
		"__gt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: char const *\n"
		"\n"
		"__gt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: char const *\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__gt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: std::string const &\n"
		"\n"
		"__gt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::string const &\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		""},
	 { "__le__", _wrap___le__, METH_VARARGS, "\n"
		"__le__(lhs, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::DateTime const &\n"
		"rhs: FIX::DateTime const &\n"
		"\n"
		"__le__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: char const *\n"
		"\n"
		"__le__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: char const *\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__le__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: std::string const &\n"
		"\n"
		"__le__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::string const &\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		""},
	 { "__ge__", _wrap___ge__, METH_VARARGS, "\n"
		"__ge__(lhs, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::DateTime const &\n"
		"rhs: FIX::DateTime const &\n"
		"\n"
		"__ge__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: char const *\n"
		"\n"
		"__ge__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: char const *\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__ge__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: std::string const &\n"
		"\n"
		"__ge__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::string const &\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		""},
	 { "delete_StringField", _wrap_delete_StringField, METH_O, "delete_StringField(self)"},
	 { "StringField_swigregister", StringField_swigregister, METH_O, NULL},
	 { "StringField_swiginit", StringField_swiginit, METH_VARARGS, NULL},
	 { "new_CharField", _wrap_new_CharField, METH_VARARGS, "\n"
		"CharField(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: char\n"
		"\n"
		"new_CharField(field) -> CharField\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "CharField_setValue", _wrap_CharField_setValue, METH_VARARGS, "\n"
		"CharField_setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: char\n"
		"\n"
		""},
	 { "CharField_getValue", _wrap_CharField_getValue, METH_O, "CharField_getValue(self) -> char"},
	 { "delete_CharField", _wrap_delete_CharField, METH_O, "delete_CharField(self)"},
	 { "CharField_swigregister", CharField_swigregister, METH_O, NULL},
	 { "CharField_swiginit", CharField_swiginit, METH_VARARGS, NULL},
	 { "new_DoubleField", _wrap_new_DoubleField, METH_VARARGS, "\n"
		"DoubleField(field, data, padding=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: double\n"
		"padding: int\n"
		"\n"
		"new_DoubleField(field) -> DoubleField\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DoubleField_setValue", _wrap_DoubleField_setValue, METH_VARARGS, "\n"
		"DoubleField_setValue(self, value, padding=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: double\n"
		"padding: int\n"
		"\n"
		""},
	 { "DoubleField_getValue", _wrap_DoubleField_getValue, METH_O, "DoubleField_getValue(self) -> double"},
	 { "delete_DoubleField", _wrap_delete_DoubleField, METH_O, "delete_DoubleField(self)"},
	 { "DoubleField_swigregister", DoubleField_swigregister, METH_O, NULL},
	 { "DoubleField_swiginit", DoubleField_swiginit, METH_VARARGS, NULL},
	 { "new_IntField", _wrap_new_IntField, METH_VARARGS, "\n"
		"IntField(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: int\n"
		"\n"
		"new_IntField(field) -> IntField\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "IntField_setValue", _wrap_IntField_setValue, METH_VARARGS, "\n"
		"IntField_setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int\n"
		"\n"
		""},
	 { "IntField_getValue", _wrap_IntField_getValue, METH_O, "IntField_getValue(self) -> int"},
	 { "delete_IntField", _wrap_delete_IntField, METH_O, "delete_IntField(self)"},
	 { "IntField_swigregister", IntField_swigregister, METH_O, NULL},
	 { "IntField_swiginit", IntField_swiginit, METH_VARARGS, NULL},
	 { "new_Int64Field", _wrap_new_Int64Field, METH_VARARGS, "\n"
		"Int64Field(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: int64_t\n"
		"\n"
		"new_Int64Field(field) -> Int64Field\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "Int64Field_setValue", _wrap_Int64Field_setValue, METH_VARARGS, "\n"
		"Int64Field_setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int64_t\n"
		"\n"
		""},
	 { "Int64Field_getValue", _wrap_Int64Field_getValue, METH_O, "Int64Field_getValue(self) -> int64_t"},
	 { "delete_Int64Field", _wrap_delete_Int64Field, METH_O, "delete_Int64Field(self)"},
	 { "Int64Field_swigregister", Int64Field_swigregister, METH_O, NULL},
	 { "Int64Field_swiginit", Int64Field_swiginit, METH_VARARGS, NULL},
	 { "new_UInt64Field", _wrap_new_UInt64Field, METH_VARARGS, "\n"
		"UInt64Field(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: uint64_t\n"
		"\n"
		"new_UInt64Field(field) -> UInt64Field\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "UInt64Field_setValue", _wrap_UInt64Field_setValue, METH_VARARGS, "\n"
		"UInt64Field_setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: uint64_t\n"
		"\n"
		""},
	 { "UInt64Field_getValue", _wrap_UInt64Field_getValue, METH_O, "UInt64Field_getValue(self) -> uint64_t"},
	 { "delete_UInt64Field", _wrap_delete_UInt64Field, METH_O, "delete_UInt64Field(self)"},
	 { "UInt64Field_swigregister", UInt64Field_swigregister, METH_O, NULL},
	 { "UInt64Field_swiginit", UInt64Field_swiginit, METH_VARARGS, NULL},
	 { "new_BoolField", _wrap_new_BoolField, METH_VARARGS, "\n"
		"BoolField(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: bool\n"
		"\n"
		"new_BoolField(field) -> BoolField\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "BoolField_setValue", _wrap_BoolField_setValue, METH_VARARGS, "\n"
		"BoolField_setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "BoolField_getValue", _wrap_BoolField_getValue, METH_O, "BoolField_getValue(self) -> bool"},
	 { "BoolField___nonzero__", _wrap_BoolField___nonzero__, METH_O, "BoolField___nonzero__(self) -> bool"},
	 { "delete_BoolField", _wrap_delete_BoolField, METH_O, "delete_BoolField(self)"},
	 { "BoolField_swigregister", BoolField_swigregister, METH_O, NULL},
	 { "BoolField_swiginit", BoolField_swiginit, METH_VARARGS, NULL},
	 { "new_UtcTimeStampField", _wrap_new_UtcTimeStampField, METH_VARARGS, "\n"
		"UtcTimeStampField(field, data, precision=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: FIX::UtcTimeStamp const &\n"
		"precision: int\n"
		"\n"
		"UtcTimeStampField(field, precision=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "UtcTimeStampField_setValue", _wrap_UtcTimeStampField_setValue, METH_VARARGS, "\n"
		"UtcTimeStampField_setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "UtcTimeStampField_getValue", _wrap_UtcTimeStampField_getValue, METH_O, "UtcTimeStampField_getValue(self) -> UtcTimeStamp"},
	 { "UtcTimeStampField___lt__", _wrap_UtcTimeStampField___lt__, METH_VARARGS, "\n"
		"UtcTimeStampField___lt__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcTimeStampField const &\n"
		"\n"
		""},
	 { "UtcTimeStampField___eq__", _wrap_UtcTimeStampField___eq__, METH_VARARGS, "\n"
		"UtcTimeStampField___eq__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcTimeStampField const &\n"
		"\n"
		""},
	 { "UtcTimeStampField___ne__", _wrap_UtcTimeStampField___ne__, METH_VARARGS, "\n"
		"UtcTimeStampField___ne__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcTimeStampField const &\n"
		"\n"
		""},
	 { "delete_UtcTimeStampField", _wrap_delete_UtcTimeStampField, METH_O, "delete_UtcTimeStampField(self)"},
	 { "UtcTimeStampField_swigregister", UtcTimeStampField_swigregister, METH_O, NULL},
	 { "UtcTimeStampField_swiginit", UtcTimeStampField_swiginit, METH_VARARGS, NULL},
	 { "new_UtcDateField", _wrap_new_UtcDateField, METH_VARARGS, "\n"
		"UtcDateField(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: FIX::UtcDate const &\n"
		"\n"
		"new_UtcDateField(field) -> UtcDateField\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "UtcDateField_setValue", _wrap_UtcDateField_setValue, METH_VARARGS, "\n"
		"UtcDateField_setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::UtcDate const &\n"
		"\n"
		""},
	 { "UtcDateField_getValue", _wrap_UtcDateField_getValue, METH_O, "UtcDateField_getValue(self) -> UtcDate"},
	 { "UtcDateField___lt__", _wrap_UtcDateField___lt__, METH_VARARGS, "\n"
		"UtcDateField___lt__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcDateField const &\n"
		"\n"
		""},
	 { "UtcDateField___eq__", _wrap_UtcDateField___eq__, METH_VARARGS, "\n"
		"UtcDateField___eq__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcDateField const &\n"
		"\n"
		""},
	 { "UtcDateField___ne__", _wrap_UtcDateField___ne__, METH_VARARGS, "\n"
		"UtcDateField___ne__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcDateField const &\n"
		"\n"
		""},
	 { "delete_UtcDateField", _wrap_delete_UtcDateField, METH_O, "delete_UtcDateField(self)"},
	 { "UtcDateField_swigregister", UtcDateField_swigregister, METH_O, NULL},
	 { "UtcDateField_swiginit", UtcDateField_swiginit, METH_VARARGS, NULL},
	 { "new_UtcTimeOnlyField", _wrap_new_UtcTimeOnlyField, METH_VARARGS, "\n"
		"UtcTimeOnlyField(field, data, precision=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: FIX::UtcTimeOnly const &\n"
		"precision: int\n"
		"\n"
		"UtcTimeOnlyField(field, precision=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "UtcTimeOnlyField_setValue", _wrap_UtcTimeOnlyField_setValue, METH_VARARGS, "\n"
		"UtcTimeOnlyField_setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::UtcTimeOnly const &\n"
		"\n"
		""},
	 { "UtcTimeOnlyField_getValue", _wrap_UtcTimeOnlyField_getValue, METH_O, "UtcTimeOnlyField_getValue(self) -> UtcTimeOnly"},
	 { "UtcTimeOnlyField___lt__", _wrap_UtcTimeOnlyField___lt__, METH_VARARGS, "\n"
		"UtcTimeOnlyField___lt__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcTimeOnlyField const &\n"
		"\n"
		""},
	 { "UtcTimeOnlyField___eq__", _wrap_UtcTimeOnlyField___eq__, METH_VARARGS, "\n"
		"UtcTimeOnlyField___eq__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcTimeOnlyField const &\n"
		"\n"
		""},
	 { "UtcTimeOnlyField___ne__", _wrap_UtcTimeOnlyField___ne__, METH_VARARGS, "\n"
		"UtcTimeOnlyField___ne__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcTimeOnlyField const &\n"
		"\n"
		""},
	 { "delete_UtcTimeOnlyField", _wrap_delete_UtcTimeOnlyField, METH_O, "delete_UtcTimeOnlyField(self)"},
	 { "UtcTimeOnlyField_swigregister", UtcTimeOnlyField_swigregister, METH_O, NULL},
	 { "UtcTimeOnlyField_swiginit", UtcTimeOnlyField_swiginit, METH_VARARGS, NULL},
	 { "new_CheckSumField", _wrap_new_CheckSumField, METH_VARARGS, "\n"
		"CheckSumField(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: int\n"
		"\n"
		"new_CheckSumField(field) -> CheckSumField\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "CheckSumField_setValue", _wrap_CheckSumField_setValue, METH_VARARGS, "\n"
		"CheckSumField_setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int\n"
		"\n"
		""},
	 { "CheckSumField_getValue", _wrap_CheckSumField_getValue, METH_O, "CheckSumField_getValue(self) -> int"},
	 { "delete_CheckSumField", _wrap_delete_CheckSumField, METH_O, "delete_CheckSumField(self)"},
	 { "CheckSumField_swigregister", CheckSumField_swigregister, METH_O, NULL},
	 { "CheckSumField_swiginit", CheckSumField_swiginit, METH_VARARGS, NULL},
	 { "new_FieldMap", _wrap_new_FieldMap, METH_VARARGS, "\n"
		"FieldMap(order=message_order(message_order::normal))\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"order: message_order const &\n"
		"\n"
		"FieldMap(order)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"order: int const []\n"
		"\n"
		"FieldMap(copy)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"copy: FIX::FieldMap const &\n"
		"\n"
		"new_FieldMap(rhs) -> FieldMap\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::FieldMap &&\n"
		"\n"
		""},
	 { "delete_FieldMap", _wrap_delete_FieldMap, METH_O, "delete_FieldMap(self)"},
	 { "FieldMap_setField", _wrap_FieldMap_setField, METH_VARARGS, "\n"
		"FieldMap_setField(self, field, overwrite=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: FIX::FieldBase const &\n"
		"overwrite: bool\n"
		"\n"
		"FieldMap_setField(self, tag, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "FieldMap_getFieldIfSet", _wrap_FieldMap_getFieldIfSet, METH_VARARGS, "\n"
		"FieldMap_getFieldIfSet(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: FIX::FieldBase &\n"
		"\n"
		""},
	 { "FieldMap_getField", _wrap_FieldMap_getField, METH_VARARGS, "\n"
		"FieldMap_getField(self, field) -> FieldBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: FIX::FieldBase &\n"
		"\n"
		"FieldMap_getField(self, tag) -> std::string const &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_getFieldRef", _wrap_FieldMap_getFieldRef, METH_VARARGS, "\n"
		"FieldMap_getFieldRef(self, tag) -> FieldBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_getFieldPtr", _wrap_FieldMap_getFieldPtr, METH_VARARGS, "\n"
		"FieldMap_getFieldPtr(self, tag) -> FieldBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_isSetField", _wrap_FieldMap_isSetField, METH_VARARGS, "\n"
		"FieldMap_isSetField(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: FIX::FieldBase const &\n"
		"\n"
		"FieldMap_isSetField(self, tag) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_removeField", _wrap_FieldMap_removeField, METH_VARARGS, "\n"
		"FieldMap_removeField(self, tag)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_addGroup", _wrap_FieldMap_addGroup, METH_VARARGS, "\n"
		"FieldMap_addGroup(self, tag, group, setCount=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"group: FIX::FieldMap const &\n"
		"setCount: bool\n"
		"\n"
		""},
	 { "FieldMap_addGroupPtr", _wrap_FieldMap_addGroupPtr, METH_VARARGS, "\n"
		"FieldMap_addGroupPtr(self, tag, group, setCount=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"group: FIX::FieldMap *\n"
		"setCount: bool\n"
		"\n"
		""},
	 { "FieldMap_replaceGroup", _wrap_FieldMap_replaceGroup, METH_VARARGS, "\n"
		"FieldMap_replaceGroup(self, num, tag, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: int\n"
		"tag: int\n"
		"group: FIX::FieldMap const &\n"
		"\n"
		""},
	 { "FieldMap_getGroup", _wrap_FieldMap_getGroup, METH_VARARGS, "\n"
		"FieldMap_getGroup(self, num, tag, group) -> FieldMap\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: int\n"
		"tag: int\n"
		"group: FIX::FieldMap &\n"
		"\n"
		""},
	 { "FieldMap_getGroupRef", _wrap_FieldMap_getGroupRef, METH_VARARGS, "\n"
		"FieldMap_getGroupRef(self, num, tag) -> FieldMap\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: int\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_getGroupPtr", _wrap_FieldMap_getGroupPtr, METH_VARARGS, "\n"
		"FieldMap_getGroupPtr(self, num, tag) -> FieldMap\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: int\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_groups", _wrap_FieldMap_groups, METH_O, "FieldMap_groups(self) -> FIX::FieldMap::Groups const &"},
	 { "FieldMap_removeGroup", _wrap_FieldMap_removeGroup, METH_VARARGS, "\n"
		"FieldMap_removeGroup(self, num, tag)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: int\n"
		"tag: int\n"
		"\n"
		"FieldMap_removeGroup(self, tag)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_hasGroup", _wrap_FieldMap_hasGroup, METH_VARARGS, "\n"
		"FieldMap_hasGroup(self, tag) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		"FieldMap_hasGroup(self, num, tag) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: int\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_groupCount", _wrap_FieldMap_groupCount, METH_VARARGS, "\n"
		"FieldMap_groupCount(self, tag) -> size_t\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_clear", _wrap_FieldMap_clear, METH_O, "FieldMap_clear(self)"},
	 { "FieldMap_isEmpty", _wrap_FieldMap_isEmpty, METH_O, "FieldMap_isEmpty(self) -> bool"},
	 { "FieldMap_totalFields", _wrap_FieldMap_totalFields, METH_O, "FieldMap_totalFields(self) -> size_t"},
	 { "FieldMap_calculateString", _wrap_FieldMap_calculateString, METH_VARARGS, "\n"
		"FieldMap_calculateString(self, arg2) -> std::string &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string &\n"
		"\n"
		""},
	 { "FieldMap_calculateLength", _wrap_FieldMap_calculateLength, METH_VARARGS, "\n"
		"FieldMap_calculateLength(self, beginStringField=FIELD::BeginString, bodyLengthField=FIELD::BodyLength, checkSumField=FIELD::CheckSum) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"beginStringField: int\n"
		"bodyLengthField: int\n"
		"checkSumField: int\n"
		"\n"
		""},
	 { "FieldMap_calculateTotal", _wrap_FieldMap_calculateTotal, METH_VARARGS, "\n"
		"FieldMap_calculateTotal(self, checkSumField=FIELD::CheckSum) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"checkSumField: int\n"
		"\n"
		""},
	 { "FieldMap_begin", _wrap_FieldMap_begin, METH_VARARGS, "\n"
		"FieldMap_begin(self) -> FIX::FieldMap::iterator\n"
		"FieldMap_begin(self) -> FIX::FieldMap::const_iterator\n"
		""},
	 { "FieldMap_end", _wrap_FieldMap_end, METH_VARARGS, "\n"
		"FieldMap_end(self) -> FIX::FieldMap::iterator\n"
		"FieldMap_end(self) -> FIX::FieldMap::const_iterator\n"
		""},
	 { "FieldMap_g_begin", _wrap_FieldMap_g_begin, METH_VARARGS, "\n"
		"FieldMap_g_begin(self) -> FIX::FieldMap::g_iterator\n"
		"FieldMap_g_begin(self) -> FIX::FieldMap::g_const_iterator\n"
		""},
	 { "FieldMap_g_end", _wrap_FieldMap_g_end, METH_VARARGS, "\n"
		"FieldMap_g_end(self) -> FIX::FieldMap::g_iterator\n"
		"FieldMap_g_end(self) -> FIX::FieldMap::g_const_iterator\n"
		""},
	 { "FieldMap_swigregister", FieldMap_swigregister, METH_O, NULL},
	 { "FieldMap_swiginit", FieldMap_swiginit, METH_VARARGS, NULL},
	 { "new_Header", _wrap_new_Header, METH_VARARGS, "\n"
		"Header()\n"
		"new_Header(order) -> Header\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"order: message_order const &\n"
		"\n"
		""},
	 { "Header_addGroup", _wrap_Header_addGroup, METH_VARARGS, "\n"
		"Header_addGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Header_replaceGroup", _wrap_Header_replaceGroup, METH_VARARGS, "\n"
		"Header_replaceGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Header_getGroup", _wrap_Header_getGroup, METH_VARARGS, "\n"
		"Header_getGroup(self, num, group) -> Group &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group &\n"
		"\n"
		""},
	 { "Header_removeGroup", _wrap_Header_removeGroup, METH_VARARGS, "\n"
		"Header_removeGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		"Header_removeGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Header_hasGroup", _wrap_Header_hasGroup, METH_VARARGS, "\n"
		"Header_hasGroup(self, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		"Header_hasGroup(self, num, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "delete_Header", _wrap_delete_Header, METH_O, "delete_Header(self)"},
	 { "Header_swigregister", Header_swigregister, METH_O, NULL},
	 { "Header_swiginit", Header_swiginit, METH_VARARGS, NULL},
	 { "new_Trailer", _wrap_new_Trailer, METH_VARARGS, "\n"
		"Trailer()\n"
		"new_Trailer(order) -> Trailer\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"order: message_order const &\n"
		"\n"
		""},
	 { "Trailer_addGroup", _wrap_Trailer_addGroup, METH_VARARGS, "\n"
		"Trailer_addGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Trailer_replaceGroup", _wrap_Trailer_replaceGroup, METH_VARARGS, "\n"
		"Trailer_replaceGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Trailer_getGroup", _wrap_Trailer_getGroup, METH_VARARGS, "\n"
		"Trailer_getGroup(self, num, group) -> Group &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group &\n"
		"\n"
		""},
	 { "Trailer_removeGroup", _wrap_Trailer_removeGroup, METH_VARARGS, "\n"
		"Trailer_removeGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		"Trailer_removeGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Trailer_hasGroup", _wrap_Trailer_hasGroup, METH_VARARGS, "\n"
		"Trailer_hasGroup(self, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		"Trailer_hasGroup(self, num, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "delete_Trailer", _wrap_delete_Trailer, METH_O, "delete_Trailer(self)"},
	 { "Trailer_swigregister", Trailer_swigregister, METH_O, NULL},
	 { "Trailer_swiginit", Trailer_swiginit, METH_VARARGS, NULL},
	 { "new_Message", _wrap_new_Message, METH_VARARGS, "\n"
		"Message()\n"
		"Message(hdrOrder, trlOrder, order)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hdrOrder: message_order const &\n"
		"trlOrder: message_order const &\n"
		"order: message_order const &\n"
		"\n"
		"Message(string, validate=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"validate: bool\n"
		"\n"
		"Message(string, dataDictionary, validate=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"dataDictionary: FIX::DataDictionary const &\n"
		"validate: bool\n"
		"\n"
		"Message(string, sessionDataDictionary, applicationDataDictionary, validate=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"sessionDataDictionary: FIX::DataDictionary const &\n"
		"applicationDataDictionary: FIX::DataDictionary const &\n"
		"validate: bool\n"
		"\n"
		"Message(headerOrder, trailerOrder, order, string, dataDictionary, validate=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"headerOrder: message_order const &\n"
		"trailerOrder: message_order const &\n"
		"order: message_order const &\n"
		"string: std::string const &\n"
		"dataDictionary: FIX::DataDictionary const &\n"
		"validate: bool\n"
		"\n"
		"Message(headerOrder, trailerOrder, order, string, sessionDataDictionary, applicationDataDictionary, validate=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"headerOrder: message_order const &\n"
		"trailerOrder: message_order const &\n"
		"order: message_order const &\n"
		"string: std::string const &\n"
		"sessionDataDictionary: FIX::DataDictionary const &\n"
		"applicationDataDictionary: FIX::DataDictionary const &\n"
		"validate: bool\n"
		"\n"
		"Message(arg1)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Message const &\n"
		"\n"
		"new_Message(arg1) -> Message\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Message &&\n"
		"\n"
		""},
	 { "delete_Message", _wrap_delete_Message, METH_O, "delete_Message(self)"},
	 { "Message_InitializeXML", _wrap_Message_InitializeXML, METH_O, "\n"
		"Message_InitializeXML(string) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"\n"
		""},
	 { "Message_addGroup", _wrap_Message_addGroup, METH_VARARGS, "\n"
		"Message_addGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Message_replaceGroup", _wrap_Message_replaceGroup, METH_VARARGS, "\n"
		"Message_replaceGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Message_getGroup", _wrap_Message_getGroup, METH_VARARGS, "\n"
		"Message_getGroup(self, num, group) -> Group &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group &\n"
		"\n"
		""},
	 { "Message_removeGroup", _wrap_Message_removeGroup, METH_VARARGS, "\n"
		"Message_removeGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		"Message_removeGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Message_hasGroup", _wrap_Message_hasGroup, METH_VARARGS, "\n"
		"Message_hasGroup(self, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		"Message_hasGroup(self, num, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Message_toString", _wrap_Message_toString, METH_VARARGS, "\n"
		"Message_toString(self, beginStringField=FIELD::BeginString, bodyLengthField=FIELD::BodyLength, checkSumField=FIELD::CheckSum) -> std::string\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"beginStringField: int\n"
		"bodyLengthField: int\n"
		"checkSumField: int\n"
		"\n"
		"Message_toString(self, arg2, beginStringField=FIELD::BeginString, bodyLengthField=FIELD::BodyLength, checkSumField=FIELD::CheckSum) -> std::string\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string &\n"
		"beginStringField: int\n"
		"bodyLengthField: int\n"
		"checkSumField: int\n"
		"\n"
		""},
	 { "Message_toXML", _wrap_Message_toXML, METH_VARARGS, "\n"
		"Message_toXML(self) -> std::string\n"
		"Message_toXML(self, arg2) -> std::string &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string &\n"
		"\n"
		""},
	 { "Message_reverseRoute", _wrap_Message_reverseRoute, METH_VARARGS, "\n"
		"Message_reverseRoute(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::Header const &\n"
		"\n"
		""},
	 { "Message_setString", _wrap_Message_setString, METH_VARARGS, "\n"
		"Message_setString(self, string)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"\n"
		"Message_setString(self, string, validate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"validate: bool\n"
		"\n"
		"Message_setString(self, string, validate, pDataDictionary)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"validate: bool\n"
		"pDataDictionary: FIX::DataDictionary const *\n"
		"\n"
		"Message_setString(self, string, validate, pSessionDataDictionary, pApplicationDataDictionary)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"validate: bool\n"
		"pSessionDataDictionary: FIX::DataDictionary const *\n"
		"pApplicationDataDictionary: FIX::DataDictionary const *\n"
		"\n"
		""},
	 { "Message_setGroup", _wrap_Message_setGroup, METH_VARARGS, "\n"
		"Message_setGroup(self, msg, field, string, pos, map, dataDictionary)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msg: std::string const &\n"
		"field: FIX::FieldBase const &\n"
		"string: std::string const &\n"
		"pos: std::string::size_type &\n"
		"map: FIX::FieldMap &\n"
		"dataDictionary: DataDictionary const &\n"
		"\n"
		""},
	 { "Message_setStringHeader", _wrap_Message_setStringHeader, METH_VARARGS, "\n"
		"Message_setStringHeader(self, string) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"\n"
		""},
	 { "Message_getHeader", _wrap_Message_getHeader, METH_VARARGS, "\n"
		"Message_getHeader(self) -> Header\n"
		"Message_getHeader(self) -> Header\n"
		""},
	 { "Message_getTrailer", _wrap_Message_getTrailer, METH_VARARGS, "\n"
		"Message_getTrailer(self) -> Trailer\n"
		"Message_getTrailer(self) -> Trailer\n"
		""},
	 { "Message_hasValidStructure", _wrap_Message_hasValidStructure, METH_VARARGS, "\n"
		"Message_hasValidStructure(self, tag) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int &\n"
		"\n"
		""},
	 { "Message_bodyLength", _wrap_Message_bodyLength, METH_VARARGS, "\n"
		"Message_bodyLength(self, beginStringField=FIELD::BeginString, bodyLengthField=FIELD::BodyLength, checkSumField=FIELD::CheckSum) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"beginStringField: int\n"
		"bodyLengthField: int\n"
		"checkSumField: int\n"
		"\n"
		""},
	 { "Message_checkSum", _wrap_Message_checkSum, METH_VARARGS, "\n"
		"Message_checkSum(self, checkSumField=FIELD::CheckSum) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"checkSumField: int\n"
		"\n"
		""},
	 { "Message_isAdmin", _wrap_Message_isAdmin, METH_O, "Message_isAdmin(self) -> bool"},
	 { "Message_isApp", _wrap_Message_isApp, METH_O, "Message_isApp(self) -> bool"},
	 { "Message_isEmpty", _wrap_Message_isEmpty, METH_O, "Message_isEmpty(self) -> bool"},
	 { "Message_clear", _wrap_Message_clear, METH_O, "Message_clear(self)"},
	 { "Message_isAdminMsgType", _wrap_Message_isAdminMsgType, METH_O, "\n"
		"Message_isAdminMsgType(msgType) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: MsgType const &\n"
		"\n"
		""},
	 { "Message_toApplVerID", _wrap_Message_toApplVerID, METH_O, "\n"
		"Message_toApplVerID(value) -> ApplVerID\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: BeginString const &\n"
		"\n"
		""},
	 { "Message_toBeginString", _wrap_Message_toBeginString, METH_O, "\n"
		"Message_toBeginString(applVerID) -> BeginString\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"applVerID: ApplVerID const &\n"
		"\n"
		""},
	 { "Message_isHeaderField", _wrap_Message_isHeaderField, METH_VARARGS, "\n"
		"Message_isHeaderField(field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		"Message_isHeaderField(field, pD=None) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: FIX::FieldBase const &\n"
		"pD: DataDictionary const *\n"
		"\n"
		"Message_isHeaderField(field, pD) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"pD: DataDictionary const *\n"
		"\n"
		""},
	 { "Message_isTrailerField", _wrap_Message_isTrailerField, METH_VARARGS, "\n"
		"Message_isTrailerField(field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		"Message_isTrailerField(field, pD=None) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: FIX::FieldBase const &\n"
		"pD: DataDictionary const *\n"
		"\n"
		"Message_isTrailerField(field, pD) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"pD: DataDictionary const *\n"
		"\n"
		""},
	 { "Message_getSessionID", _wrap_Message_getSessionID, METH_VARARGS, "\n"
		"Message_getSessionID(self, qualifier=\"\") -> SessionID\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"qualifier: std::string const &\n"
		"\n"
		""},
	 { "Message_setSessionID", _wrap_Message_setSessionID, METH_VARARGS, "\n"
		"Message_setSessionID(self, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: SessionID const &\n"
		"\n"
		""},
	 { "Message___str__", _wrap_Message___str__, METH_O, "Message___str__(self) -> std::string"},
	 { "Message_swigregister", Message_swigregister, METH_O, NULL},
	 { "Message_swiginit", Message_swiginit, METH_VARARGS, NULL},
	 { "identifyType", _wrap_identifyType, METH_O, "\n"
		"identifyType(message) -> MsgType\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: std::string const &\n"
		"\n"
		""},
	 { "new_Group", _wrap_new_Group, METH_VARARGS, "\n"
		"Group(field, delim)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"delim: int\n"
		"\n"
		"Group(field, delim, order)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"delim: int\n"
		"order: int const []\n"
		"\n"
		"Group(field, delim, order)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"delim: int\n"
		"order: message_order const &\n"
		"\n"
		"new_Group(copy) -> Group\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"copy: FIX::Group const &\n"
		"\n"
		""},
	 { "Group_field", _wrap_Group_field, METH_O, "Group_field(self) -> int"},
	 { "Group_delim", _wrap_Group_delim, METH_O, "Group_delim(self) -> int"},
	 { "Group_addGroup", _wrap_Group_addGroup, METH_VARARGS, "\n"
		"Group_addGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Group_replaceGroup", _wrap_Group_replaceGroup, METH_VARARGS, "\n"
		"Group_replaceGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Group_getGroup", _wrap_Group_getGroup, METH_VARARGS, "\n"
		"Group_getGroup(self, num, group) -> Group\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group &\n"
		"\n"
		""},
	 { "Group_removeGroup", _wrap_Group_removeGroup, METH_VARARGS, "\n"
		"Group_removeGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		"Group_removeGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Group_hasGroup", _wrap_Group_hasGroup, METH_VARARGS, "\n"
		"Group_hasGroup(self, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		"Group_hasGroup(self, num, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "delete_Group", _wrap_delete_Group, METH_O, "delete_Group(self)"},
	 { "Group_swigregister", Group_swigregister, METH_O, NULL},
	 { "Group_swiginit", Group_swiginit, METH_VARARGS, NULL},
	 { "new_BeginString", _wrap_new_BeginString, METH_VARARGS, "\n"
		"BeginString()\n"
		"new_BeginString(value) -> BeginString\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::STRING const &\n"
		"\n"
		""},
	 { "delete_BeginString", _wrap_delete_BeginString, METH_O, "delete_BeginString(self)"},
	 { "BeginString_swigregister", BeginString_swigregister, METH_O, NULL},
	 { "BeginString_swiginit", BeginString_swiginit, METH_VARARGS, NULL},
	 { "new_SenderCompID", _wrap_new_SenderCompID, METH_VARARGS, "\n"
		"SenderCompID()\n"
		"new_SenderCompID(value) -> SenderCompID\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::STRING const &\n"
		"\n"
		""},
	 { "delete_SenderCompID", _wrap_delete_SenderCompID, METH_O, "delete_SenderCompID(self)"},
	 { "SenderCompID_swigregister", SenderCompID_swigregister, METH_O, NULL},
	 { "SenderCompID_swiginit", SenderCompID_swiginit, METH_VARARGS, NULL},
	 { "new_TargetCompID", _wrap_new_TargetCompID, METH_VARARGS, "\n"
		"TargetCompID()\n"
		"new_TargetCompID(value) -> TargetCompID\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::STRING const &\n"
		"\n"
		""},
	 { "delete_TargetCompID", _wrap_delete_TargetCompID, METH_O, "delete_TargetCompID(self)"},
	 { "TargetCompID_swigregister", TargetCompID_swigregister, METH_O, NULL},
	 { "TargetCompID_swiginit", TargetCompID_swiginit, METH_VARARGS, NULL},
	 { "new_SessionID", _wrap_new_SessionID, METH_VARARGS, "\n"
		"SessionID()\n"
		"SessionID(beginString, senderCompID, targetCompID, sessionQualifier=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"beginString: std::string const &\n"
		"senderCompID: std::string const &\n"
		"targetCompID: std::string const &\n"
		"sessionQualifier: std::string const &\n"
		"\n"
		""},
	 { "SessionID_getBeginString", _wrap_SessionID_getBeginString, METH_O, "SessionID_getBeginString(self) -> BeginString"},
	 { "SessionID_getSenderCompID", _wrap_SessionID_getSenderCompID, METH_O, "SessionID_getSenderCompID(self) -> SenderCompID"},
	 { "SessionID_getTargetCompID", _wrap_SessionID_getTargetCompID, METH_O, "SessionID_getTargetCompID(self) -> TargetCompID"},
	 { "SessionID_getSessionQualifier", _wrap_SessionID_getSessionQualifier, METH_O, "SessionID_getSessionQualifier(self) -> std::string const &"},
	 { "SessionID_isFIXT", _wrap_SessionID_isFIXT, METH_O, "SessionID_isFIXT(self) -> bool const"},
	 { "SessionID_toStringFrozen", _wrap_SessionID_toStringFrozen, METH_O, "SessionID_toStringFrozen(self) -> std::string const &"},
	 { "SessionID_fromString", _wrap_SessionID_fromString, METH_VARARGS, "\n"
		"SessionID_fromString(self, str)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"str: std::string const &\n"
		"\n"
		""},
	 { "SessionID_toString", _wrap_SessionID_toString, METH_VARARGS, "\n"
		"SessionID_toString(self) -> std::string\n"
		"SessionID_toString(self, str) -> std::string &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"str: std::string &\n"
		"\n"
		""},
	 { "SessionID___invert__", _wrap_SessionID___invert__, METH_O, "SessionID___invert__(self) -> SessionID"},
	 { "SessionID___str__", _wrap_SessionID___str__, METH_O, "SessionID___str__(self) -> std::string"},
	 { "delete_SessionID", _wrap_delete_SessionID, METH_O, "delete_SessionID(self)"},
	 { "SessionID_swigregister", SessionID_swigregister, METH_O, NULL},
	 { "SessionID_swiginit", SessionID_swiginit, METH_VARARGS, NULL},
	 { "new_Dictionary", _wrap_new_Dictionary, METH_VARARGS, "\n"
		"Dictionary(name)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name: std::string const &\n"
		"\n"
		"new_Dictionary() -> Dictionary\n"
		""},
	 { "delete_Dictionary", _wrap_delete_Dictionary, METH_O, "delete_Dictionary(self)"},
	 { "Dictionary_getName", _wrap_Dictionary_getName, METH_O, "Dictionary_getName(self) -> std::string"},
	 { "Dictionary_size", _wrap_Dictionary_size, METH_O, "Dictionary_size(self) -> size_t"},
	 { "Dictionary_getString", _wrap_Dictionary_getString, METH_VARARGS, "\n"
		"Dictionary_getString(self, arg2, capitalize=False) -> std::string\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"capitalize: bool\n"
		"\n"
		""},
	 { "Dictionary_getInt", _wrap_Dictionary_getInt, METH_VARARGS, "\n"
		"Dictionary_getInt(self, arg2) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "Dictionary_getDouble", _wrap_Dictionary_getDouble, METH_VARARGS, "\n"
		"Dictionary_getDouble(self, arg2) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "Dictionary_getBool", _wrap_Dictionary_getBool, METH_VARARGS, "\n"
		"Dictionary_getBool(self, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "Dictionary_getDay", _wrap_Dictionary_getDay, METH_VARARGS, "\n"
		"Dictionary_getDay(self, arg2) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "Dictionary_setString", _wrap_Dictionary_setString, METH_VARARGS, "\n"
		"Dictionary_setString(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"arg3: std::string const &\n"
		"\n"
		""},
	 { "Dictionary_setInt", _wrap_Dictionary_setInt, METH_VARARGS, "\n"
		"Dictionary_setInt(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"arg3: int\n"
		"\n"
		""},
	 { "Dictionary_setDouble", _wrap_Dictionary_setDouble, METH_VARARGS, "\n"
		"Dictionary_setDouble(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"arg3: double\n"
		"\n"
		""},
	 { "Dictionary_setBool", _wrap_Dictionary_setBool, METH_VARARGS, "\n"
		"Dictionary_setBool(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"arg3: bool\n"
		"\n"
		""},
	 { "Dictionary_setDay", _wrap_Dictionary_setDay, METH_VARARGS, "\n"
		"Dictionary_setDay(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"arg3: int\n"
		"\n"
		""},
	 { "Dictionary_has", _wrap_Dictionary_has, METH_VARARGS, "\n"
		"Dictionary_has(self, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "Dictionary_merge", _wrap_Dictionary_merge, METH_VARARGS, "\n"
		"Dictionary_merge(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::Dictionary const &\n"
		"\n"
		""},
	 { "Dictionary_begin", _wrap_Dictionary_begin, METH_O, "Dictionary_begin(self) -> FIX::Dictionary::iterator"},
	 { "Dictionary_end", _wrap_Dictionary_end, METH_O, "Dictionary_end(self) -> FIX::Dictionary::iterator"},
	 { "Dictionary_swigregister", Dictionary_swigregister, METH_O, NULL},
	 { "Dictionary_swiginit", Dictionary_swiginit, METH_VARARGS, NULL},
	 { "new_SessionSettings", _wrap_new_SessionSettings, METH_VARARGS, "\n"
		"SessionSettings()\n"
		"SessionSettings(stream, resolveEnvVars=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"stream: std::istream &\n"
		"resolveEnvVars: bool\n"
		"\n"
		"SessionSettings(file, resolveEnvVars=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"file: std::string const &\n"
		"resolveEnvVars: bool\n"
		"\n"
		""},
	 { "SessionSettings_has", _wrap_SessionSettings_has, METH_VARARGS, "\n"
		"SessionSettings_has(self, arg2) -> bool const\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SessionSettings_get", _wrap_SessionSettings_get, METH_VARARGS, "\n"
		"SessionSettings_get(self, arg2) -> Dictionary\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		"SessionSettings_get(self) -> Dictionary\n"
		""},
	 { "SessionSettings_set", _wrap_SessionSettings_set, METH_VARARGS, "\n"
		"SessionSettings_set(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SessionID const &\n"
		"arg3: FIX::Dictionary\n"
		"\n"
		"SessionSettings_set(self, defaults)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"defaults: FIX::Dictionary const &\n"
		"\n"
		""},
	 { "SessionSettings_size", _wrap_SessionSettings_size, METH_O, "SessionSettings_size(self) -> size_t"},
	 { "SessionSettings_getSessions", _wrap_SessionSettings_getSessions, METH_O, "SessionSettings_getSessions(self) -> SessionIDSet"},
	 { "__rshift__", _wrap___rshift__, METH_VARARGS, "\n"
		"__rshift__(arg1, arg2) -> std::istream\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::istream &\n"
		"arg2: FIX::SessionID &\n"
		"\n"
		"__rshift__(arg1, arg2) -> std::istream &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::istream &\n"
		"arg2: FIX::SessionSettings &\n"
		"\n"
		""},
	 { "__lshift__", _wrap___lshift__, METH_VARARGS, "\n"
		"__lshift__(stream, field) -> std::ostream\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"stream: std::ostream &\n"
		"field: FIX::FieldBase const &\n"
		"\n"
		"__lshift__(stream, message) -> std::ostream\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"stream: std::ostream &\n"
		"message: FIX::Message const &\n"
		"\n"
		"__lshift__(arg1, arg2) -> std::ostream\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::ostream &\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		"__lshift__(arg1, arg2) -> std::ostream &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::ostream &\n"
		"arg2: FIX::SessionSettings const &\n"
		"\n"
		""},
	 { "SessionSettings_setFromString", _wrap_SessionSettings_setFromString, METH_VARARGS, "\n"
		"SessionSettings_setFromString(self, str)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"str: std::string const &\n"
		"\n"
		""},
	 { "delete_SessionSettings", _wrap_delete_SessionSettings, METH_O, "delete_SessionSettings(self)"},
	 { "SessionSettings_swigregister", SessionSettings_swigregister, METH_O, NULL},
	 { "SessionSettings_swiginit", SessionSettings_swiginit, METH_VARARGS, NULL},
	 { "new_Session", _wrap_new_Session, METH_VARARGS, "\n"
		"new_Session(timestamper, arg2, arg3, arg4, arg5, arg6, heartBtInt, pLogFactory) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"timestamper: std::function< FIX::UtcTimeStamp () >\n"
		"arg2: Application &\n"
		"arg3: MessageStoreFactory &\n"
		"arg4: FIX::SessionID const &\n"
		"arg5: DataDictionaryProvider const &\n"
		"arg6: TimeRange const &\n"
		"heartBtInt: int\n"
		"pLogFactory: LogFactory *\n"
		"\n"
		""},
	 { "delete_Session", _wrap_delete_Session, METH_O, "delete_Session(self)"},
	 { "Session_logon", _wrap_Session_logon, METH_O, "Session_logon(self)"},
	 { "Session_logout", _wrap_Session_logout, METH_VARARGS, "\n"
		"Session_logout(self, reason=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"reason: std::string const &\n"
		"\n"
		""},
	 { "Session_isEnabled", _wrap_Session_isEnabled, METH_O, "Session_isEnabled(self) -> bool"},
	 { "Session_sentLogon", _wrap_Session_sentLogon, METH_O, "Session_sentLogon(self) -> bool"},
	 { "Session_sentLogout", _wrap_Session_sentLogout, METH_O, "Session_sentLogout(self) -> bool"},
	 { "Session_receivedLogon", _wrap_Session_receivedLogon, METH_O, "Session_receivedLogon(self) -> bool"},
	 { "Session_isLoggedOn", _wrap_Session_isLoggedOn, METH_O, "Session_isLoggedOn(self) -> bool"},
	 { "Session_reset", _wrap_Session_reset, METH_O, "Session_reset(self)"},
	 { "Session_refresh", _wrap_Session_refresh, METH_O, "Session_refresh(self)"},
	 { "Session_setNextSenderMsgSeqNum", _wrap_Session_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"Session_setNextSenderMsgSeqNum(self, num)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: FIX::SEQNUM\n"
		"\n"
		""},
	 { "Session_setNextTargetMsgSeqNum", _wrap_Session_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"Session_setNextTargetMsgSeqNum(self, num)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: FIX::SEQNUM\n"
		"\n"
		""},
	 { "Session_getSessionID", _wrap_Session_getSessionID, METH_O, "Session_getSessionID(self) -> SessionID"},
	 { "Session_setDataDictionaryProvider", _wrap_Session_setDataDictionaryProvider, METH_VARARGS, "\n"
		"Session_setDataDictionaryProvider(self, dataDictionaryProvider)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dataDictionaryProvider: DataDictionaryProvider const &\n"
		"\n"
		""},
	 { "Session_getDataDictionaryProvider", _wrap_Session_getDataDictionaryProvider, METH_O, "Session_getDataDictionaryProvider(self) -> DataDictionaryProvider const &"},
	 { "Session_sendToTarget", _wrap_Session_sendToTarget, METH_VARARGS, "\n"
		"Session_sendToTarget(message, qualifier=\"\") -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message &\n"
		"qualifier: std::string const &\n"
		"\n"
		"Session_sendToTarget(message, sessionID) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message &\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		"Session_sendToTarget(arg1, senderCompID, targetCompID, qualifier=\"\") -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Message &\n"
		"senderCompID: FIX::SenderCompID const &\n"
		"targetCompID: FIX::TargetCompID const &\n"
		"qualifier: std::string const &\n"
		"\n"
		"Session_sendToTarget(message, senderCompID, targetCompID, qualifier=\"\") -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message &\n"
		"senderCompID: std::string const &\n"
		"targetCompID: std::string const &\n"
		"qualifier: std::string const &\n"
		"\n"
		""},
	 { "Session_getSessions", _wrap_Session_getSessions, METH_NOARGS, "Session_getSessions() -> SessionIDSet"},
	 { "Session_doesSessionExist", _wrap_Session_doesSessionExist, METH_O, "\n"
		"Session_doesSessionExist(arg1) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Session_lookupSession", _wrap_Session_lookupSession, METH_VARARGS, "\n"
		"Session_lookupSession(arg1) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		"Session_lookupSession(arg1, reverse=False) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::string const &\n"
		"reverse: bool\n"
		"\n"
		""},
	 { "Session_isSessionRegistered", _wrap_Session_isSessionRegistered, METH_O, "\n"
		"Session_isSessionRegistered(arg1) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Session_registerSession", _wrap_Session_registerSession, METH_O, "\n"
		"Session_registerSession(arg1) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Session_unregisterSession", _wrap_Session_unregisterSession, METH_O, "\n"
		"Session_unregisterSession(arg1)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Session_numSessions", _wrap_Session_numSessions, METH_NOARGS, "Session_numSessions() -> size_t"},
	 { "Session_isSessionTime", _wrap_Session_isSessionTime, METH_VARARGS, "\n"
		"Session_isSessionTime(self, now) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "Session_isLogonTime", _wrap_Session_isLogonTime, METH_VARARGS, "\n"
		"Session_isLogonTime(self, now) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "Session_isInitiator", _wrap_Session_isInitiator, METH_O, "Session_isInitiator(self) -> bool"},
	 { "Session_isAcceptor", _wrap_Session_isAcceptor, METH_O, "Session_isAcceptor(self) -> bool"},
	 { "Session_getLogonTime", _wrap_Session_getLogonTime, METH_O, "Session_getLogonTime(self) -> TimeRange const &"},
	 { "Session_setLogonTime", _wrap_Session_setLogonTime, METH_VARARGS, "\n"
		"Session_setLogonTime(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: TimeRange const &\n"
		"\n"
		""},
	 { "Session_getSenderDefaultApplVerID", _wrap_Session_getSenderDefaultApplVerID, METH_O, "Session_getSenderDefaultApplVerID(self) -> std::string const &"},
	 { "Session_setSenderDefaultApplVerID", _wrap_Session_setSenderDefaultApplVerID, METH_VARARGS, "\n"
		"Session_setSenderDefaultApplVerID(self, senderDefaultApplVerID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"senderDefaultApplVerID: std::string const &\n"
		"\n"
		""},
	 { "Session_getTargetDefaultApplVerID", _wrap_Session_getTargetDefaultApplVerID, METH_O, "Session_getTargetDefaultApplVerID(self) -> std::string const &"},
	 { "Session_setTargetDefaultApplVerID", _wrap_Session_setTargetDefaultApplVerID, METH_VARARGS, "\n"
		"Session_setTargetDefaultApplVerID(self, targetDefaultApplVerID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"targetDefaultApplVerID: std::string const &\n"
		"\n"
		""},
	 { "Session_getSendRedundantResendRequests", _wrap_Session_getSendRedundantResendRequests, METH_O, "Session_getSendRedundantResendRequests(self) -> bool"},
	 { "Session_setSendRedundantResendRequests", _wrap_Session_setSendRedundantResendRequests, METH_VARARGS, "\n"
		"Session_setSendRedundantResendRequests(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getCheckCompId", _wrap_Session_getCheckCompId, METH_O, "Session_getCheckCompId(self) -> bool"},
	 { "Session_setCheckCompId", _wrap_Session_setCheckCompId, METH_VARARGS, "\n"
		"Session_setCheckCompId(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getCheckLatency", _wrap_Session_getCheckLatency, METH_O, "Session_getCheckLatency(self) -> bool"},
	 { "Session_setCheckLatency", _wrap_Session_setCheckLatency, METH_VARARGS, "\n"
		"Session_setCheckLatency(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getMaxLatency", _wrap_Session_getMaxLatency, METH_O, "Session_getMaxLatency(self) -> int"},
	 { "Session_setMaxLatency", _wrap_Session_setMaxLatency, METH_VARARGS, "\n"
		"Session_setMaxLatency(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int\n"
		"\n"
		""},
	 { "Session_getLogonTimeout", _wrap_Session_getLogonTimeout, METH_O, "Session_getLogonTimeout(self) -> int"},
	 { "Session_setLogonTimeout", _wrap_Session_setLogonTimeout, METH_VARARGS, "\n"
		"Session_setLogonTimeout(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int\n"
		"\n"
		""},
	 { "Session_getLogoutTimeout", _wrap_Session_getLogoutTimeout, METH_O, "Session_getLogoutTimeout(self) -> int"},
	 { "Session_setLogoutTimeout", _wrap_Session_setLogoutTimeout, METH_VARARGS, "\n"
		"Session_setLogoutTimeout(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int\n"
		"\n"
		""},
	 { "Session_getResetOnLogon", _wrap_Session_getResetOnLogon, METH_O, "Session_getResetOnLogon(self) -> bool"},
	 { "Session_setResetOnLogon", _wrap_Session_setResetOnLogon, METH_VARARGS, "\n"
		"Session_setResetOnLogon(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getResetOnLogout", _wrap_Session_getResetOnLogout, METH_O, "Session_getResetOnLogout(self) -> bool"},
	 { "Session_setResetOnLogout", _wrap_Session_setResetOnLogout, METH_VARARGS, "\n"
		"Session_setResetOnLogout(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getResetOnDisconnect", _wrap_Session_getResetOnDisconnect, METH_O, "Session_getResetOnDisconnect(self) -> bool"},
	 { "Session_setResetOnDisconnect", _wrap_Session_setResetOnDisconnect, METH_VARARGS, "\n"
		"Session_setResetOnDisconnect(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getRefreshOnLogon", _wrap_Session_getRefreshOnLogon, METH_O, "Session_getRefreshOnLogon(self) -> bool"},
	 { "Session_setRefreshOnLogon", _wrap_Session_setRefreshOnLogon, METH_VARARGS, "\n"
		"Session_setRefreshOnLogon(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getMillisecondsInTimeStamp", _wrap_Session_getMillisecondsInTimeStamp, METH_O, "Session_getMillisecondsInTimeStamp(self) -> bool"},
	 { "Session_setMillisecondsInTimeStamp", _wrap_Session_setMillisecondsInTimeStamp, METH_VARARGS, "\n"
		"Session_setMillisecondsInTimeStamp(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getTimestampPrecision", _wrap_Session_getTimestampPrecision, METH_O, "Session_getTimestampPrecision(self) -> int"},
	 { "Session_setTimestampPrecision", _wrap_Session_setTimestampPrecision, METH_VARARGS, "\n"
		"Session_setTimestampPrecision(self, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"precision: int\n"
		"\n"
		""},
	 { "Session_getSupportedTimestampPrecision", _wrap_Session_getSupportedTimestampPrecision, METH_O, "Session_getSupportedTimestampPrecision(self) -> int"},
	 { "Session_supportsSubSecondTimestamps", _wrap_Session_supportsSubSecondTimestamps, METH_O, "\n"
		"Session_supportsSubSecondTimestamps(beginString) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"beginString: std::string const &\n"
		"\n"
		""},
	 { "Session_getPersistMessages", _wrap_Session_getPersistMessages, METH_O, "Session_getPersistMessages(self) -> bool"},
	 { "Session_setPersistMessages", _wrap_Session_setPersistMessages, METH_VARARGS, "\n"
		"Session_setPersistMessages(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getValidateLengthAndChecksum", _wrap_Session_getValidateLengthAndChecksum, METH_O, "Session_getValidateLengthAndChecksum(self) -> bool"},
	 { "Session_setValidateLengthAndChecksum", _wrap_Session_setValidateLengthAndChecksum, METH_VARARGS, "\n"
		"Session_setValidateLengthAndChecksum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getSendNextExpectedMsgSeqNum", _wrap_Session_getSendNextExpectedMsgSeqNum, METH_O, "Session_getSendNextExpectedMsgSeqNum(self) -> bool"},
	 { "Session_setSendNextExpectedMsgSeqNum", _wrap_Session_setSendNextExpectedMsgSeqNum, METH_VARARGS, "\n"
		"Session_setSendNextExpectedMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getIsNonStopSession", _wrap_Session_getIsNonStopSession, METH_O, "Session_getIsNonStopSession(self) -> bool"},
	 { "Session_setIsNonStopSession", _wrap_Session_setIsNonStopSession, METH_VARARGS, "\n"
		"Session_setIsNonStopSession(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getAllowedRemoteAddresses", _wrap_Session_getAllowedRemoteAddresses, METH_O, "Session_getAllowedRemoteAddresses(self) -> std::set< std::string,std::less< std::string >,std::allocator< std::string > > const &"},
	 { "Session_setAllowedRemoteAddresses", _wrap_Session_setAllowedRemoteAddresses, METH_VARARGS, "\n"
		"Session_setAllowedRemoteAddresses(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::set< std::string,std::less< std::string >,std::allocator< std::string > > const &\n"
		"\n"
		""},
	 { "Session_inAllowedRemoteAddresses", _wrap_Session_inAllowedRemoteAddresses, METH_VARARGS, "\n"
		"Session_inAllowedRemoteAddresses(self, value) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "Session_setResponder", _wrap_Session_setResponder, METH_VARARGS, "\n"
		"Session_setResponder(self, pR)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pR: Responder *\n"
		"\n"
		""},
	 { "Session_send", _wrap_Session_send, METH_VARARGS, "\n"
		"Session_send(self, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::Message &\n"
		"\n"
		""},
	 { "Session_next", _wrap_Session_next, METH_VARARGS, "\n"
		"Session_next(self, now)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		"Session_next(self, arg2, now, queued=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"now: FIX::UtcTimeStamp const &\n"
		"queued: bool\n"
		"\n"
		"Session_next(self, arg2, now, queued=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::Message const &\n"
		"now: FIX::UtcTimeStamp const &\n"
		"queued: bool\n"
		"\n"
		""},
	 { "Session_disconnect", _wrap_Session_disconnect, METH_O, "Session_disconnect(self)"},
	 { "Session_getExpectedSenderNum", _wrap_Session_getExpectedSenderNum, METH_O, "Session_getExpectedSenderNum(self) -> FIX::SEQNUM"},
	 { "Session_getExpectedTargetNum", _wrap_Session_getExpectedTargetNum, METH_O, "Session_getExpectedTargetNum(self) -> FIX::SEQNUM"},
	 { "Session_getLog", _wrap_Session_getLog, METH_O, "Session_getLog(self) -> Log *"},
	 { "Session_getStore", _wrap_Session_getStore, METH_O, "Session_getStore(self) -> MessageStore const *"},
	 { "Session_swigregister", Session_swigregister, METH_O, NULL},
	 { "Session_swiginit", Session_swiginit, METH_VARARGS, NULL},
	 { "delete_LogFactory", _wrap_delete_LogFactory, METH_O, "delete_LogFactory(self)"},
	 { "LogFactory_create", _wrap_LogFactory_create, METH_VARARGS, "\n"
		"LogFactory_create(self) -> Log\n"
		"LogFactory_create(self, arg0) -> Log\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::SessionID const &\n"
		"\n"
		""},
	 { "LogFactory_destroy", _wrap_LogFactory_destroy, METH_VARARGS, "\n"
		"LogFactory_destroy(self, arg0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::Log *\n"
		"\n"
		""},
	 { "new_LogFactory", _wrap_new_LogFactory, METH_O, "\n"
		"new_LogFactory(_self) -> LogFactory\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"self: PyObject *\n"
		"\n"
		""},
	 { "disown_LogFactory", _wrap_disown_LogFactory, METH_O, NULL},
	 { "LogFactory_swigregister", LogFactory_swigregister, METH_O, NULL},
	 { "LogFactory_swiginit", LogFactory_swiginit, METH_VARARGS, NULL},
	 { "new_ScreenLogFactory", _wrap_new_ScreenLogFactory, METH_VARARGS, "\n"
		"ScreenLogFactory(settings)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"settings: FIX::SessionSettings\n"
		"\n"
		"new_ScreenLogFactory(incoming, outgoing, event) -> ScreenLogFactory\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"incoming: bool\n"
		"outgoing: bool\n"
		"event: bool\n"
		"\n"
		""},
	 { "ScreenLogFactory_create", _wrap_ScreenLogFactory_create, METH_VARARGS, "\n"
		"ScreenLogFactory_create(self) -> Log\n"
		"ScreenLogFactory_create(self, arg2) -> Log\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		""},
	 { "ScreenLogFactory_destroy", _wrap_ScreenLogFactory_destroy, METH_VARARGS, "\n"
		"ScreenLogFactory_destroy(self, log)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"log: FIX::Log *\n"
		"\n"
		""},
	 { "delete_ScreenLogFactory", _wrap_delete_ScreenLogFactory, METH_O, "delete_ScreenLogFactory(self)"},
	 { "ScreenLogFactory_swigregister", ScreenLogFactory_swigregister, METH_O, NULL},
	 { "ScreenLogFactory_swiginit", ScreenLogFactory_swiginit, METH_VARARGS, NULL},
	 { "delete_Log", _wrap_delete_Log, METH_O, "delete_Log(self)"},
	 { "Log_clear", _wrap_Log_clear, METH_O, "Log_clear(self)"},
	 { "Log_backup", _wrap_Log_backup, METH_O, "Log_backup(self)"},
	 { "Log_onIncoming", _wrap_Log_onIncoming, METH_VARARGS, "\n"
		"Log_onIncoming(self, arg0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: std::string const &\n"
		"\n"
		""},
	 { "Log_onOutgoing", _wrap_Log_onOutgoing, METH_VARARGS, "\n"
		"Log_onOutgoing(self, arg0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: std::string const &\n"
		"\n"
		""},
	 { "Log_onEvent", _wrap_Log_onEvent, METH_VARARGS, "\n"
		"Log_onEvent(self, arg0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: std::string const &\n"
		"\n"
		""},
	 { "new_Log", _wrap_new_Log, METH_O, "\n"
		"new_Log(_self) -> Log\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"self: PyObject *\n"
		"\n"
		""},
	 { "disown_Log", _wrap_disown_Log, METH_O, NULL},
	 { "Log_swigregister", Log_swigregister, METH_O, NULL},
	 { "Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
	 { "NullLog_clear", _wrap_NullLog_clear, METH_O, "NullLog_clear(self)"},
	 { "NullLog_backup", _wrap_NullLog_backup, METH_O, "NullLog_backup(self)"},
	 { "NullLog_onIncoming", _wrap_NullLog_onIncoming, METH_VARARGS, "\n"
		"NullLog_onIncoming(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "NullLog_onOutgoing", _wrap_NullLog_onOutgoing, METH_VARARGS, "\n"
		"NullLog_onOutgoing(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "NullLog_onEvent", _wrap_NullLog_onEvent, METH_VARARGS, "\n"
		"NullLog_onEvent(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "new_NullLog", _wrap_new_NullLog, METH_NOARGS, "new_NullLog() -> NullLog"},
	 { "delete_NullLog", _wrap_delete_NullLog, METH_O, "delete_NullLog(self)"},
	 { "NullLog_swigregister", NullLog_swigregister, METH_O, NULL},
	 { "NullLog_swiginit", NullLog_swiginit, METH_VARARGS, NULL},
	 { "new_ScreenLog", _wrap_new_ScreenLog, METH_VARARGS, "\n"
		"ScreenLog(incoming, outgoing, event)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"incoming: bool\n"
		"outgoing: bool\n"
		"event: bool\n"
		"\n"
		"new_ScreenLog(sessionID, incoming, outgoing, event) -> ScreenLog\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"incoming: bool\n"
		"outgoing: bool\n"
		"event: bool\n"
		"\n"
		""},
	 { "ScreenLog_clear", _wrap_ScreenLog_clear, METH_O, "ScreenLog_clear(self)"},
	 { "ScreenLog_backup", _wrap_ScreenLog_backup, METH_O, "ScreenLog_backup(self)"},
	 { "ScreenLog_onIncoming", _wrap_ScreenLog_onIncoming, METH_VARARGS, "\n"
		"ScreenLog_onIncoming(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "ScreenLog_onOutgoing", _wrap_ScreenLog_onOutgoing, METH_VARARGS, "\n"
		"ScreenLog_onOutgoing(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "ScreenLog_onEvent", _wrap_ScreenLog_onEvent, METH_VARARGS, "\n"
		"ScreenLog_onEvent(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "delete_ScreenLog", _wrap_delete_ScreenLog, METH_O, "delete_ScreenLog(self)"},
	 { "ScreenLog_swigregister", ScreenLog_swigregister, METH_O, NULL},
	 { "ScreenLog_swiginit", ScreenLog_swiginit, METH_VARARGS, NULL},
	 { "new_FileLogFactory", _wrap_new_FileLogFactory, METH_VARARGS, "\n"
		"FileLogFactory(settings)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"settings: FIX::SessionSettings const &\n"
		"\n"
		"FileLogFactory(path)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path: std::string const &\n"
		"\n"
		"new_FileLogFactory(path, backupPath) -> FileLogFactory\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path: std::string const &\n"
		"backupPath: std::string const &\n"
		"\n"
		""},
	 { "FileLogFactory_create", _wrap_FileLogFactory_create, METH_VARARGS, "\n"
		"FileLogFactory_create(self) -> Log\n"
		"FileLogFactory_create(self, arg2) -> Log\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		""},
	 { "FileLogFactory_destroy", _wrap_FileLogFactory_destroy, METH_VARARGS, "\n"
		"FileLogFactory_destroy(self, log)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"log: FIX::Log *\n"
		"\n"
		""},
	 { "delete_FileLogFactory", _wrap_delete_FileLogFactory, METH_O, "delete_FileLogFactory(self)"},
	 { "FileLogFactory_swigregister", FileLogFactory_swigregister, METH_O, NULL},
	 { "FileLogFactory_swiginit", FileLogFactory_swiginit, METH_VARARGS, NULL},
	 { "new_FileLog", _wrap_new_FileLog, METH_VARARGS, "\n"
		"FileLog(path)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path: std::string const &\n"
		"\n"
		"FileLog(path, backupPath)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path: std::string const &\n"
		"backupPath: std::string const &\n"
		"\n"
		"FileLog(path, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path: std::string const &\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		"new_FileLog(path, backupPath, sessionID) -> FileLog\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path: std::string const &\n"
		"backupPath: std::string const &\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "delete_FileLog", _wrap_delete_FileLog, METH_O, "delete_FileLog(self)"},
	 { "FileLog_clear", _wrap_FileLog_clear, METH_O, "FileLog_clear(self)"},
	 { "FileLog_backup", _wrap_FileLog_backup, METH_O, "FileLog_backup(self)"},
	 { "FileLog_onIncoming", _wrap_FileLog_onIncoming, METH_VARARGS, "\n"
		"FileLog_onIncoming(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "FileLog_onOutgoing", _wrap_FileLog_onOutgoing, METH_VARARGS, "\n"
		"FileLog_onOutgoing(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "FileLog_onEvent", _wrap_FileLog_onEvent, METH_VARARGS, "\n"
		"FileLog_onEvent(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "FileLog_swigregister", FileLog_swigregister, METH_O, NULL},
	 { "FileLog_swiginit", FileLog_swiginit, METH_VARARGS, NULL},
	 { "delete_MessageStoreFactory", _wrap_delete_MessageStoreFactory, METH_O, "delete_MessageStoreFactory(self)"},
	 { "MessageStoreFactory_create", _wrap_MessageStoreFactory_create, METH_VARARGS, "\n"
		"MessageStoreFactory_create(self, now, arg3) -> MessageStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"arg3: FIX::SessionID const &\n"
		"\n"
		""},
	 { "MessageStoreFactory_destroy", _wrap_MessageStoreFactory_destroy, METH_VARARGS, "\n"
		"MessageStoreFactory_destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::MessageStore *\n"
		"\n"
		""},
	 { "MessageStoreFactory_swigregister", MessageStoreFactory_swigregister, METH_O, NULL},
	 { "MemoryStoreFactory_create", _wrap_MemoryStoreFactory_create, METH_VARARGS, "\n"
		"MemoryStoreFactory_create(self, now, arg3) -> MessageStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"arg3: FIX::SessionID const &\n"
		"\n"
		""},
	 { "MemoryStoreFactory_destroy", _wrap_MemoryStoreFactory_destroy, METH_VARARGS, "\n"
		"MemoryStoreFactory_destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::MessageStore *\n"
		"\n"
		""},
	 { "new_MemoryStoreFactory", _wrap_new_MemoryStoreFactory, METH_NOARGS, "new_MemoryStoreFactory() -> MemoryStoreFactory"},
	 { "delete_MemoryStoreFactory", _wrap_delete_MemoryStoreFactory, METH_O, "delete_MemoryStoreFactory(self)"},
	 { "MemoryStoreFactory_swigregister", MemoryStoreFactory_swigregister, METH_O, NULL},
	 { "MemoryStoreFactory_swiginit", MemoryStoreFactory_swiginit, METH_VARARGS, NULL},
	 { "delete_MessageStore", _wrap_delete_MessageStore, METH_O, "delete_MessageStore(self)"},
	 { "MessageStore_set", _wrap_MessageStore_set, METH_VARARGS, "\n"
		"MessageStore_set(self, arg2, arg3) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: std::string const &\n"
		"\n"
		""},
	 { "MessageStore_get", _wrap_MessageStore_get, METH_VARARGS, "\n"
		"MessageStore_get(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: FIX::SEQNUM\n"
		"arg4: std::vector< std::string,std::allocator< std::string > > &\n"
		"\n"
		""},
	 { "MessageStore_getNextSenderMsgSeqNum", _wrap_MessageStore_getNextSenderMsgSeqNum, METH_O, "MessageStore_getNextSenderMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "MessageStore_getNextTargetMsgSeqNum", _wrap_MessageStore_getNextTargetMsgSeqNum, METH_O, "MessageStore_getNextTargetMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "MessageStore_setNextSenderMsgSeqNum", _wrap_MessageStore_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"MessageStore_setNextSenderMsgSeqNum(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"\n"
		""},
	 { "MessageStore_setNextTargetMsgSeqNum", _wrap_MessageStore_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"MessageStore_setNextTargetMsgSeqNum(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"\n"
		""},
	 { "MessageStore_incrNextSenderMsgSeqNum", _wrap_MessageStore_incrNextSenderMsgSeqNum, METH_O, "MessageStore_incrNextSenderMsgSeqNum(self)"},
	 { "MessageStore_incrNextTargetMsgSeqNum", _wrap_MessageStore_incrNextTargetMsgSeqNum, METH_O, "MessageStore_incrNextTargetMsgSeqNum(self)"},
	 { "MessageStore_getCreationTime", _wrap_MessageStore_getCreationTime, METH_O, "MessageStore_getCreationTime(self) -> UtcTimeStamp"},
	 { "MessageStore_reset", _wrap_MessageStore_reset, METH_VARARGS, "\n"
		"MessageStore_reset(self, now)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "MessageStore_refresh", _wrap_MessageStore_refresh, METH_O, "MessageStore_refresh(self)"},
	 { "MessageStore_swigregister", MessageStore_swigregister, METH_O, NULL},
	 { "new_MemoryStore", _wrap_new_MemoryStore, METH_O, "\n"
		"new_MemoryStore(now) -> MemoryStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "MemoryStore_set", _wrap_MemoryStore_set, METH_VARARGS, "\n"
		"MemoryStore_set(self, arg2, arg3) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: std::string const &\n"
		"\n"
		""},
	 { "MemoryStore_get", _wrap_MemoryStore_get, METH_VARARGS, "\n"
		"MemoryStore_get(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: FIX::SEQNUM\n"
		"arg4: std::vector< std::string,std::allocator< std::string > > &\n"
		"\n"
		""},
	 { "MemoryStore_getNextSenderMsgSeqNum", _wrap_MemoryStore_getNextSenderMsgSeqNum, METH_O, "MemoryStore_getNextSenderMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "MemoryStore_getNextTargetMsgSeqNum", _wrap_MemoryStore_getNextTargetMsgSeqNum, METH_O, "MemoryStore_getNextTargetMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "MemoryStore_setNextSenderMsgSeqNum", _wrap_MemoryStore_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"MemoryStore_setNextSenderMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "MemoryStore_setNextTargetMsgSeqNum", _wrap_MemoryStore_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"MemoryStore_setNextTargetMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "MemoryStore_incrNextSenderMsgSeqNum", _wrap_MemoryStore_incrNextSenderMsgSeqNum, METH_O, "MemoryStore_incrNextSenderMsgSeqNum(self)"},
	 { "MemoryStore_incrNextTargetMsgSeqNum", _wrap_MemoryStore_incrNextTargetMsgSeqNum, METH_O, "MemoryStore_incrNextTargetMsgSeqNum(self)"},
	 { "MemoryStore_setCreationTime", _wrap_MemoryStore_setCreationTime, METH_VARARGS, "\n"
		"MemoryStore_setCreationTime(self, creationTime)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"creationTime: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "MemoryStore_getCreationTime", _wrap_MemoryStore_getCreationTime, METH_O, "MemoryStore_getCreationTime(self) -> UtcTimeStamp"},
	 { "MemoryStore_reset", _wrap_MemoryStore_reset, METH_VARARGS, "\n"
		"MemoryStore_reset(self, now)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "MemoryStore_refresh", _wrap_MemoryStore_refresh, METH_O, "MemoryStore_refresh(self)"},
	 { "delete_MemoryStore", _wrap_delete_MemoryStore, METH_O, "delete_MemoryStore(self)"},
	 { "MemoryStore_swigregister", MemoryStore_swigregister, METH_O, NULL},
	 { "MemoryStore_swiginit", MemoryStore_swiginit, METH_VARARGS, NULL},
	 { "new_MessageStoreFactoryExceptionWrapper", _wrap_new_MessageStoreFactoryExceptionWrapper, METH_O, "\n"
		"new_MessageStoreFactoryExceptionWrapper(pFactory) -> MessageStoreFactoryExceptionWrapper\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pFactory: FIX::MessageStoreFactory *\n"
		"\n"
		""},
	 { "MessageStoreFactoryExceptionWrapper_create", _wrap_MessageStoreFactoryExceptionWrapper_create, METH_VARARGS, "\n"
		"MessageStoreFactoryExceptionWrapper_create(self, now, arg3, arg4, arg5) -> MessageStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"arg3: FIX::SessionID const &\n"
		"arg4: bool &\n"
		"arg5: FIX::ConfigError &\n"
		"\n"
		""},
	 { "MessageStoreFactoryExceptionWrapper_destroy", _wrap_MessageStoreFactoryExceptionWrapper_destroy, METH_VARARGS, "\n"
		"MessageStoreFactoryExceptionWrapper_destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::MessageStore *\n"
		"\n"
		""},
	 { "delete_MessageStoreFactoryExceptionWrapper", _wrap_delete_MessageStoreFactoryExceptionWrapper, METH_O, "delete_MessageStoreFactoryExceptionWrapper(self)"},
	 { "MessageStoreFactoryExceptionWrapper_swigregister", MessageStoreFactoryExceptionWrapper_swigregister, METH_O, NULL},
	 { "MessageStoreFactoryExceptionWrapper_swiginit", MessageStoreFactoryExceptionWrapper_swiginit, METH_VARARGS, NULL},
	 { "new_MessageStoreExceptionWrapper", _wrap_new_MessageStoreExceptionWrapper, METH_O, "\n"
		"new_MessageStoreExceptionWrapper(pStore) -> MessageStoreExceptionWrapper\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pStore: FIX::MessageStore *\n"
		"\n"
		""},
	 { "delete_MessageStoreExceptionWrapper", _wrap_delete_MessageStoreExceptionWrapper, METH_O, "delete_MessageStoreExceptionWrapper(self)"},
	 { "MessageStoreExceptionWrapper_set", _wrap_MessageStoreExceptionWrapper_set, METH_VARARGS, "\n"
		"MessageStoreExceptionWrapper_set(self, arg2, arg3, arg4, arg5) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: std::string const &\n"
		"arg4: bool &\n"
		"arg5: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_get", _wrap_MessageStoreExceptionWrapper_get, METH_VARARGS, "\n"
		"MessageStoreExceptionWrapper_get(self, arg2, arg3, arg4, arg5, arg6)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: FIX::SEQNUM\n"
		"arg4: std::vector< std::string,std::allocator< std::string > > &\n"
		"arg5: bool &\n"
		"arg6: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_getNextSenderMsgSeqNum", _wrap_MessageStoreExceptionWrapper_getNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"MessageStoreExceptionWrapper_getNextSenderMsgSeqNum(self, arg2, arg3) -> FIX::SEQNUM\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: bool &\n"
		"arg3: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_getNextTargetMsgSeqNum", _wrap_MessageStoreExceptionWrapper_getNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"MessageStoreExceptionWrapper_getNextTargetMsgSeqNum(self, arg2, arg3) -> FIX::SEQNUM\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: bool &\n"
		"arg3: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_setNextSenderMsgSeqNum", _wrap_MessageStoreExceptionWrapper_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"MessageStoreExceptionWrapper_setNextSenderMsgSeqNum(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: bool &\n"
		"arg4: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_setNextTargetMsgSeqNum", _wrap_MessageStoreExceptionWrapper_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"MessageStoreExceptionWrapper_setNextTargetMsgSeqNum(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: bool &\n"
		"arg4: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum", _wrap_MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: bool &\n"
		"arg3: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum", _wrap_MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: bool &\n"
		"arg3: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_getCreationTime", _wrap_MessageStoreExceptionWrapper_getCreationTime, METH_VARARGS, "\n"
		"MessageStoreExceptionWrapper_getCreationTime(self, arg2, arg3) -> UtcTimeStamp\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: bool &\n"
		"arg3: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_reset", _wrap_MessageStoreExceptionWrapper_reset, METH_VARARGS, "\n"
		"MessageStoreExceptionWrapper_reset(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::UtcTimeStamp const &\n"
		"arg3: bool &\n"
		"arg4: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_refresh", _wrap_MessageStoreExceptionWrapper_refresh, METH_VARARGS, "\n"
		"MessageStoreExceptionWrapper_refresh(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: bool &\n"
		"arg3: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_swigregister", MessageStoreExceptionWrapper_swigregister, METH_O, NULL},
	 { "MessageStoreExceptionWrapper_swiginit", MessageStoreExceptionWrapper_swiginit, METH_VARARGS, NULL},
	 { "new_FileStoreFactory", _wrap_new_FileStoreFactory, METH_VARARGS, "\n"
		"FileStoreFactory(settings)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"settings: FIX::SessionSettings const &\n"
		"\n"
		"new_FileStoreFactory(path) -> FileStoreFactory\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path: std::string const &\n"
		"\n"
		""},
	 { "FileStoreFactory_create", _wrap_FileStoreFactory_create, METH_VARARGS, "\n"
		"FileStoreFactory_create(self, arg2, arg3) -> MessageStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::UtcTimeStamp const &\n"
		"arg3: FIX::SessionID const &\n"
		"\n"
		""},
	 { "FileStoreFactory_destroy", _wrap_FileStoreFactory_destroy, METH_VARARGS, "\n"
		"FileStoreFactory_destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::MessageStore *\n"
		"\n"
		""},
	 { "delete_FileStoreFactory", _wrap_delete_FileStoreFactory, METH_O, "delete_FileStoreFactory(self)"},
	 { "FileStoreFactory_swigregister", FileStoreFactory_swigregister, METH_O, NULL},
	 { "FileStoreFactory_swiginit", FileStoreFactory_swiginit, METH_VARARGS, NULL},
	 { "new_FileStore", _wrap_new_FileStore, METH_VARARGS, "\n"
		"new_FileStore(now, arg2, sessionID) -> FileStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"arg2: std::string\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "delete_FileStore", _wrap_delete_FileStore, METH_O, "delete_FileStore(self)"},
	 { "FileStore_set", _wrap_FileStore_set, METH_VARARGS, "\n"
		"FileStore_set(self, arg2, arg3) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: std::string const &\n"
		"\n"
		""},
	 { "FileStore_get", _wrap_FileStore_get, METH_VARARGS, "\n"
		"FileStore_get(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: FIX::SEQNUM\n"
		"arg4: std::vector< std::string,std::allocator< std::string > > &\n"
		"\n"
		""},
	 { "FileStore_getNextSenderMsgSeqNum", _wrap_FileStore_getNextSenderMsgSeqNum, METH_O, "FileStore_getNextSenderMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "FileStore_getNextTargetMsgSeqNum", _wrap_FileStore_getNextTargetMsgSeqNum, METH_O, "FileStore_getNextTargetMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "FileStore_setNextSenderMsgSeqNum", _wrap_FileStore_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"FileStore_setNextSenderMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "FileStore_setNextTargetMsgSeqNum", _wrap_FileStore_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"FileStore_setNextTargetMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "FileStore_incrNextSenderMsgSeqNum", _wrap_FileStore_incrNextSenderMsgSeqNum, METH_O, "FileStore_incrNextSenderMsgSeqNum(self)"},
	 { "FileStore_incrNextTargetMsgSeqNum", _wrap_FileStore_incrNextTargetMsgSeqNum, METH_O, "FileStore_incrNextTargetMsgSeqNum(self)"},
	 { "FileStore_getCreationTime", _wrap_FileStore_getCreationTime, METH_O, "FileStore_getCreationTime(self) -> UtcTimeStamp"},
	 { "FileStore_reset", _wrap_FileStore_reset, METH_VARARGS, "\n"
		"FileStore_reset(self, now)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "FileStore_refresh", _wrap_FileStore_refresh, METH_O, "FileStore_refresh(self)"},
	 { "FileStore_swigregister", FileStore_swigregister, METH_O, NULL},
	 { "FileStore_swiginit", FileStore_swiginit, METH_VARARGS, NULL},
	 { "delete_Application", _wrap_delete_Application, METH_O, "delete_Application(self)"},
	 { "Application_onCreate", _wrap_Application_onCreate, METH_VARARGS, "\n"
		"Application_onCreate(self, arg0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Application_onLogon", _wrap_Application_onLogon, METH_VARARGS, "\n"
		"Application_onLogon(self, arg0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Application_onLogout", _wrap_Application_onLogout, METH_VARARGS, "\n"
		"Application_onLogout(self, arg0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Application_toAdmin", _wrap_Application_toAdmin, METH_VARARGS, "\n"
		"Application_toAdmin(self, arg0, arg1)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::Message &\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Application_toApp", _wrap_Application_toApp, METH_VARARGS, "\n"
		"Application_toApp(self, arg0, arg1)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::Message &\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Application_fromAdmin", _wrap_Application_fromAdmin, METH_VARARGS, "\n"
		"Application_fromAdmin(self, arg0, arg1)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::Message const &\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Application_fromApp", _wrap_Application_fromApp, METH_VARARGS, "\n"
		"Application_fromApp(self, arg0, arg1)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::Message const &\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "new_Application", _wrap_new_Application, METH_O, "\n"
		"new_Application(_self) -> Application\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"self: PyObject *\n"
		"\n"
		""},
	 { "disown_Application", _wrap_disown_Application, METH_O, NULL},
	 { "Application_swigregister", Application_swigregister, METH_O, NULL},
	 { "Application_swiginit", Application_swiginit, METH_VARARGS, NULL},
	 { "new_SynchronizedApplication", _wrap_new_SynchronizedApplication, METH_O, "\n"
		"new_SynchronizedApplication(app) -> SynchronizedApplication\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"app: FIX::Application &\n"
		"\n"
		""},
	 { "SynchronizedApplication_onCreate", _wrap_SynchronizedApplication_onCreate, METH_VARARGS, "\n"
		"SynchronizedApplication_onCreate(self, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SynchronizedApplication_onLogon", _wrap_SynchronizedApplication_onLogon, METH_VARARGS, "\n"
		"SynchronizedApplication_onLogon(self, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SynchronizedApplication_onLogout", _wrap_SynchronizedApplication_onLogout, METH_VARARGS, "\n"
		"SynchronizedApplication_onLogout(self, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SynchronizedApplication_toAdmin", _wrap_SynchronizedApplication_toAdmin, METH_VARARGS, "\n"
		"SynchronizedApplication_toAdmin(self, message, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message &\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SynchronizedApplication_toApp", _wrap_SynchronizedApplication_toApp, METH_VARARGS, "\n"
		"SynchronizedApplication_toApp(self, message, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message &\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SynchronizedApplication_fromAdmin", _wrap_SynchronizedApplication_fromAdmin, METH_VARARGS, "\n"
		"SynchronizedApplication_fromAdmin(self, message, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message const &\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SynchronizedApplication_fromApp", _wrap_SynchronizedApplication_fromApp, METH_VARARGS, "\n"
		"SynchronizedApplication_fromApp(self, message, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message const &\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SynchronizedApplication_m_mutex_set", _wrap_SynchronizedApplication_m_mutex_set, METH_VARARGS, "\n"
		"SynchronizedApplication_m_mutex_set(self, m_mutex)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"m_mutex: Mutex\n"
		"\n"
		""},
	 { "SynchronizedApplication_m_mutex_get", _wrap_SynchronizedApplication_m_mutex_get, METH_O, "SynchronizedApplication_m_mutex_get(self) -> Mutex"},
	 { "SynchronizedApplication_app", _wrap_SynchronizedApplication_app, METH_O, "SynchronizedApplication_app(self) -> Application"},
	 { "SynchronizedApplication_m_app_set", _wrap_SynchronizedApplication_m_app_set, METH_VARARGS, "\n"
		"SynchronizedApplication_m_app_set(self, m_app)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"m_app: FIX::Application &\n"
		"\n"
		""},
	 { "SynchronizedApplication_m_app_get", _wrap_SynchronizedApplication_m_app_get, METH_O, "SynchronizedApplication_m_app_get(self) -> Application"},
	 { "delete_SynchronizedApplication", _wrap_delete_SynchronizedApplication, METH_O, "delete_SynchronizedApplication(self)"},
	 { "SynchronizedApplication_swigregister", SynchronizedApplication_swigregister, METH_O, NULL},
	 { "SynchronizedApplication_swiginit", SynchronizedApplication_swiginit, METH_VARARGS, NULL},
	 { "new_NullApplication", _wrap_new_NullApplication, METH_NOARGS, "new_NullApplication() -> NullApplication"},
	 { "delete_NullApplication", _wrap_delete_NullApplication, METH_O, "delete_NullApplication(self)"},
	 { "NullApplication_swigregister", NullApplication_swigregister, METH_O, NULL},
	 { "NullApplication_swiginit", NullApplication_swiginit, METH_VARARGS, NULL},
	 { "delete_Initiator", _wrap_delete_Initiator, METH_O, "delete_Initiator(self)"},
	 { "Initiator_start", _wrap_Initiator_start, METH_O, "Initiator_start(self)"},
	 { "Initiator_block", _wrap_Initiator_block, METH_O, "Initiator_block(self)"},
	 { "Initiator_poll", _wrap_Initiator_poll, METH_O, "Initiator_poll(self) -> bool"},
	 { "Initiator_stop", _wrap_Initiator_stop, METH_VARARGS, "\n"
		"Initiator_stop(self, force=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"force: bool\n"
		"\n"
		""},
	 { "Initiator_isLoggedOn", _wrap_Initiator_isLoggedOn, METH_O, "Initiator_isLoggedOn(self) -> bool"},
	 { "Initiator_getSessions", _wrap_Initiator_getSessions, METH_O, "Initiator_getSessions(self) -> SessionIDSet"},
	 { "Initiator_getSession", _wrap_Initiator_getSession, METH_VARARGS, "\n"
		"Initiator_getSession(self, sessionID, arg3) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"arg3: Responder &\n"
		"\n"
		"Initiator_getSession(self, sessionID) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Initiator_getSessionSettings", _wrap_Initiator_getSessionSettings, METH_VARARGS, "\n"
		"Initiator_getSessionSettings(self, sessionID) -> Dictionary\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Initiator_has", _wrap_Initiator_has, METH_VARARGS, "\n"
		"Initiator_has(self, id) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Initiator_isStopped", _wrap_Initiator_isStopped, METH_O, "Initiator_isStopped(self) -> bool"},
	 { "Initiator_getApplication", _wrap_Initiator_getApplication, METH_O, "Initiator_getApplication(self) -> Application"},
	 { "Initiator_getMessageStoreFactory", _wrap_Initiator_getMessageStoreFactory, METH_O, "Initiator_getMessageStoreFactory(self) -> MessageStoreFactory"},
	 { "Initiator_getLog", _wrap_Initiator_getLog, METH_O, "Initiator_getLog(self) -> Log"},
	 { "Initiator_swigregister", Initiator_swigregister, METH_O, NULL},
	 { "new_SocketInitiatorBase", _wrap_new_SocketInitiatorBase, METH_VARARGS, "\n"
		"SocketInitiator(arg1, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"\n"
		"new_SocketInitiatorBase(arg1, arg2, arg3, arg4) -> SocketInitiatorBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"arg4: FIX::LogFactory &\n"
		"\n"
		""},
	 { "delete_SocketInitiatorBase", _wrap_delete_SocketInitiatorBase, METH_O, "delete_SocketInitiatorBase(self)"},
	 { "SocketInitiatorBase_swigregister", SocketInitiatorBase_swigregister, METH_O, NULL},
	 { "SocketInitiatorBase_swiginit", SocketInitiatorBase_swiginit, METH_VARARGS, NULL},
	 { "delete_Acceptor", _wrap_delete_Acceptor, METH_O, "delete_Acceptor(self)"},
	 { "Acceptor_getLog", _wrap_Acceptor_getLog, METH_O, "Acceptor_getLog(self) -> Log"},
	 { "Acceptor_start", _wrap_Acceptor_start, METH_O, "Acceptor_start(self)"},
	 { "Acceptor_block", _wrap_Acceptor_block, METH_O, "Acceptor_block(self)"},
	 { "Acceptor_poll", _wrap_Acceptor_poll, METH_O, "Acceptor_poll(self) -> bool"},
	 { "Acceptor_stop", _wrap_Acceptor_stop, METH_VARARGS, "\n"
		"Acceptor_stop(self, force=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"force: bool\n"
		"\n"
		""},
	 { "Acceptor_isLoggedOn", _wrap_Acceptor_isLoggedOn, METH_O, "Acceptor_isLoggedOn(self) -> bool"},
	 { "Acceptor_getSessions", _wrap_Acceptor_getSessions, METH_O, "Acceptor_getSessions(self) -> SessionIDSet"},
	 { "Acceptor_getSession", _wrap_Acceptor_getSession, METH_VARARGS, "\n"
		"Acceptor_getSession(self, msg, arg3) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msg: std::string const &\n"
		"arg3: Responder &\n"
		"\n"
		"Acceptor_getSession(self, sessionID) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Acceptor_getSessionSettings", _wrap_Acceptor_getSessionSettings, METH_VARARGS, "\n"
		"Acceptor_getSessionSettings(self, sessionID) -> Dictionary\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Acceptor_has", _wrap_Acceptor_has, METH_VARARGS, "\n"
		"Acceptor_has(self, id) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Acceptor_isStopped", _wrap_Acceptor_isStopped, METH_O, "Acceptor_isStopped(self) -> bool"},
	 { "Acceptor_getApplication", _wrap_Acceptor_getApplication, METH_O, "Acceptor_getApplication(self) -> Application"},
	 { "Acceptor_getMessageStoreFactory", _wrap_Acceptor_getMessageStoreFactory, METH_O, "Acceptor_getMessageStoreFactory(self) -> MessageStoreFactory"},
	 { "Acceptor_swigregister", Acceptor_swigregister, METH_O, NULL},
	 { "new_SocketAcceptorBase", _wrap_new_SocketAcceptorBase, METH_VARARGS, "\n"
		"SocketAcceptor(arg1, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"\n"
		"new_SocketAcceptorBase(arg1, arg2, arg3, arg4) -> SocketAcceptorBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"arg4: FIX::LogFactory &\n"
		"\n"
		""},
	 { "delete_SocketAcceptorBase", _wrap_delete_SocketAcceptorBase, METH_O, "delete_SocketAcceptorBase(self)"},
	 { "SocketAcceptorBase_sessionToPort", _wrap_SocketAcceptorBase_sessionToPort, METH_O, "SocketAcceptorBase_sessionToPort(self) -> FIX::SocketAcceptor::SessionToPort const &"},
	 { "SocketAcceptorBase_swigregister", SocketAcceptorBase_swigregister, METH_O, NULL},
	 { "SocketAcceptorBase_swiginit", SocketAcceptorBase_swiginit, METH_VARARGS, NULL},
	 { "new_DataDictionary", _wrap_new_DataDictionary, METH_VARARGS, "\n"
		"DataDictionary()\n"
		"DataDictionary(copy)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"copy: FIX::DataDictionary const &\n"
		"\n"
		"DataDictionary(stream, preserveMsgFldsOrder=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"stream: std::istream &\n"
		"preserveMsgFldsOrder: bool\n"
		"\n"
		"DataDictionary(url, preserveMsgFldsOrder=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"url: std::string const &\n"
		"preserveMsgFldsOrder: bool\n"
		"\n"
		""},
	 { "delete_DataDictionary", _wrap_delete_DataDictionary, METH_O, "delete_DataDictionary(self)"},
	 { "DataDictionary_readFromURL", _wrap_DataDictionary_readFromURL, METH_VARARGS, "\n"
		"DataDictionary_readFromURL(self, url)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"url: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_readFromDocument", _wrap_DataDictionary_readFromDocument, METH_VARARGS, "\n"
		"DataDictionary_readFromDocument(self, pDoc)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pDoc: DOMDocumentPtr const &\n"
		"\n"
		""},
	 { "DataDictionary_readFromStream", _wrap_DataDictionary_readFromStream, METH_VARARGS, "\n"
		"DataDictionary_readFromStream(self, stream)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"stream: std::istream &\n"
		"\n"
		""},
	 { "DataDictionary_getOrderedFields", _wrap_DataDictionary_getOrderedFields, METH_O, "DataDictionary_getOrderedFields(self) -> message_order const &"},
	 { "DataDictionary_getHeaderOrderedFields", _wrap_DataDictionary_getHeaderOrderedFields, METH_O, "DataDictionary_getHeaderOrderedFields(self) -> message_order const &"},
	 { "DataDictionary_getTrailerOrderedFields", _wrap_DataDictionary_getTrailerOrderedFields, METH_O, "DataDictionary_getTrailerOrderedFields(self) -> message_order const &"},
	 { "DataDictionary_getMessageOrderedFields", _wrap_DataDictionary_getMessageOrderedFields, METH_VARARGS, "\n"
		"DataDictionary_getMessageOrderedFields(self, msgType) -> message_order const &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_setVersion", _wrap_DataDictionary_setVersion, METH_VARARGS, "\n"
		"DataDictionary_setVersion(self, beginString)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"beginString: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_getVersion", _wrap_DataDictionary_getVersion, METH_O, "DataDictionary_getVersion(self) -> std::string"},
	 { "DataDictionary_addField", _wrap_DataDictionary_addField, METH_VARARGS, "\n"
		"DataDictionary_addField(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_addFieldName", _wrap_DataDictionary_addFieldName, METH_VARARGS, "\n"
		"DataDictionary_addFieldName(self, field, name)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"name: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_getFieldName", _wrap_DataDictionary_getFieldName, METH_VARARGS, "\n"
		"DataDictionary_getFieldName(self, field, name) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"name: std::string &\n"
		"\n"
		""},
	 { "DataDictionary_getFieldTag", _wrap_DataDictionary_getFieldTag, METH_VARARGS, "\n"
		"DataDictionary_getFieldTag(self, name, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name: std::string const &\n"
		"field: int &\n"
		"\n"
		""},
	 { "DataDictionary_addValueName", _wrap_DataDictionary_addValueName, METH_VARARGS, "\n"
		"DataDictionary_addValueName(self, field, value, name)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"value: std::string const &\n"
		"name: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_getValueName", _wrap_DataDictionary_getValueName, METH_VARARGS, "\n"
		"DataDictionary_getValueName(self, field, value, name) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"value: std::string const &\n"
		"name: std::string &\n"
		"\n"
		""},
	 { "DataDictionary_getNameValue", _wrap_DataDictionary_getNameValue, METH_VARARGS, "\n"
		"DataDictionary_getNameValue(self, field, name, value) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"name: std::string const &\n"
		"value: std::string &\n"
		"\n"
		""},
	 { "DataDictionary_isField", _wrap_DataDictionary_isField, METH_VARARGS, "\n"
		"DataDictionary_isField(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_addMsgType", _wrap_DataDictionary_addMsgType, METH_VARARGS, "\n"
		"DataDictionary_addMsgType(self, msgType)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_isMsgType", _wrap_DataDictionary_isMsgType, METH_VARARGS, "\n"
		"DataDictionary_isMsgType(self, msgType) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_addMsgField", _wrap_DataDictionary_addMsgField, METH_VARARGS, "\n"
		"DataDictionary_addMsgField(self, msgType, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: std::string const &\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_isMsgField", _wrap_DataDictionary_isMsgField, METH_VARARGS, "\n"
		"DataDictionary_isMsgField(self, msgType, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: std::string const &\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_addHeaderField", _wrap_DataDictionary_addHeaderField, METH_VARARGS, "\n"
		"DataDictionary_addHeaderField(self, field, required)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"required: bool\n"
		"\n"
		""},
	 { "DataDictionary_isHeaderField", _wrap_DataDictionary_isHeaderField, METH_VARARGS, "\n"
		"DataDictionary_isHeaderField(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_addTrailerField", _wrap_DataDictionary_addTrailerField, METH_VARARGS, "\n"
		"DataDictionary_addTrailerField(self, field, required)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"required: bool\n"
		"\n"
		""},
	 { "DataDictionary_isTrailerField", _wrap_DataDictionary_isTrailerField, METH_VARARGS, "\n"
		"DataDictionary_isTrailerField(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_addFieldType", _wrap_DataDictionary_addFieldType, METH_VARARGS, "\n"
		"DataDictionary_addFieldType(self, field, type)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"type: enum FIX::TYPE::Type\n"
		"\n"
		""},
	 { "DataDictionary_getFieldType", _wrap_DataDictionary_getFieldType, METH_VARARGS, "\n"
		"DataDictionary_getFieldType(self, field, type) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"type: FIX::TYPE::Type &\n"
		"\n"
		""},
	 { "DataDictionary_addRequiredField", _wrap_DataDictionary_addRequiredField, METH_VARARGS, "\n"
		"DataDictionary_addRequiredField(self, msgType, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: std::string const &\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_isRequiredField", _wrap_DataDictionary_isRequiredField, METH_VARARGS, "\n"
		"DataDictionary_isRequiredField(self, msgType, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: std::string const &\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_addFieldValue", _wrap_DataDictionary_addFieldValue, METH_VARARGS, "\n"
		"DataDictionary_addFieldValue(self, field, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_hasFieldValue", _wrap_DataDictionary_hasFieldValue, METH_VARARGS, "\n"
		"DataDictionary_hasFieldValue(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_isFieldValue", _wrap_DataDictionary_isFieldValue, METH_VARARGS, "\n"
		"DataDictionary_isFieldValue(self, field, value) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_addGroup", _wrap_DataDictionary_addGroup, METH_VARARGS, "\n"
		"DataDictionary_addGroup(self, msg, field, delim, dataDictionary)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msg: std::string const &\n"
		"field: int\n"
		"delim: int\n"
		"dataDictionary: FIX::DataDictionary const &\n"
		"\n"
		""},
	 { "DataDictionary_isGroup", _wrap_DataDictionary_isGroup, METH_VARARGS, "\n"
		"DataDictionary_isGroup(self, msg, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msg: std::string const &\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_getGroup", _wrap_DataDictionary_getGroup, METH_VARARGS, "\n"
		"DataDictionary_getGroup(self, msg, field, delim, pDataDictionary) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msg: std::string const &\n"
		"field: int\n"
		"delim: int &\n"
		"pDataDictionary: FIX::DataDictionary const *&\n"
		"\n"
		""},
	 { "DataDictionary_isDataField", _wrap_DataDictionary_isDataField, METH_VARARGS, "\n"
		"DataDictionary_isDataField(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_isMultipleValueField", _wrap_DataDictionary_isMultipleValueField, METH_VARARGS, "\n"
		"DataDictionary_isMultipleValueField(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_checkFieldsOutOfOrder", _wrap_DataDictionary_checkFieldsOutOfOrder, METH_VARARGS, "\n"
		"DataDictionary_checkFieldsOutOfOrder(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "DataDictionary_checkFieldsHaveValues", _wrap_DataDictionary_checkFieldsHaveValues, METH_VARARGS, "\n"
		"DataDictionary_checkFieldsHaveValues(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "DataDictionary_checkUserDefinedFields", _wrap_DataDictionary_checkUserDefinedFields, METH_VARARGS, "\n"
		"DataDictionary_checkUserDefinedFields(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "DataDictionary_allowUnknownMsgFields", _wrap_DataDictionary_allowUnknownMsgFields, METH_VARARGS, "\n"
		"DataDictionary_allowUnknownMsgFields(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "DataDictionary_preserveMessageFieldsOrder", _wrap_DataDictionary_preserveMessageFieldsOrder, METH_VARARGS, "\n"
		"DataDictionary_preserveMessageFieldsOrder(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "DataDictionary_isMessageFieldsOrderPreserved", _wrap_DataDictionary_isMessageFieldsOrderPreserved, METH_O, "DataDictionary_isMessageFieldsOrderPreserved(self) -> bool"},
	 { "DataDictionary_validate", _wrap_DataDictionary_validate, METH_VARARGS, "\n"
		"DataDictionary_validate(self, message, pSessionDD, pAppID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message const &\n"
		"pSessionDD: FIX::DataDictionary const *const\n"
		"pAppID: FIX::DataDictionary const *const\n"
		"\n"
		"DataDictionary_validate(self, message)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message const &\n"
		"\n"
		"DataDictionary_validate(self, message, bodyOnly)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message const &\n"
		"bodyOnly: bool\n"
		"\n"
		""},
	 { "DataDictionary_swigregister", DataDictionary_swigregister, METH_O, NULL},
	 { "DataDictionary_swiginit", DataDictionary_swiginit, METH_VARARGS, NULL},
	 { "new_SSLSocketAcceptorBase", _wrap_new_SSLSocketAcceptorBase, METH_VARARGS, "\n"
		"SSLSocketAcceptor(arg1, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"\n"
		"new_SSLSocketAcceptorBase(arg1, arg2, arg3, arg4) -> SSLSocketAcceptorBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"arg4: FIX::LogFactory &\n"
		"\n"
		""},
	 { "delete_SSLSocketAcceptorBase", _wrap_delete_SSLSocketAcceptorBase, METH_O, "delete_SSLSocketAcceptorBase(self)"},
	 { "SSLSocketAcceptorBase_setPassword", _wrap_SSLSocketAcceptorBase_setPassword, METH_VARARGS, "\n"
		"SSLSocketAcceptorBase_setPassword(self, pwd)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pwd: std::string const &\n"
		"\n"
		""},
	 { "SSLSocketAcceptorBase_passwordHandleCallback", _wrap_SSLSocketAcceptorBase_passwordHandleCallback, METH_VARARGS, "\n"
		"SSLSocketAcceptorBase_passwordHandleCallback(self, buf, bufsize, verify) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"buf: char *\n"
		"bufsize: size_t\n"
		"verify: int\n"
		"\n"
		""},
	 { "SSLSocketAcceptorBase_passPhraseHandleCB", _wrap_SSLSocketAcceptorBase_passPhraseHandleCB, METH_VARARGS, "\n"
		"SSLSocketAcceptorBase_passPhraseHandleCB(buf, bufsize, verify, instance) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"buf: char *\n"
		"bufsize: int\n"
		"verify: int\n"
		"instance: void *\n"
		"\n"
		""},
	 { "SSLSocketAcceptorBase_swigregister", SSLSocketAcceptorBase_swigregister, METH_O, NULL},
	 { "SSLSocketAcceptorBase_swiginit", SSLSocketAcceptorBase_swiginit, METH_VARARGS, NULL},
	 { "new_SSLSocketInitiatorBase", _wrap_new_SSLSocketInitiatorBase, METH_VARARGS, "\n"
		"SSLSocketInitiator(arg1, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"\n"
		"new_SSLSocketInitiatorBase(arg1, arg2, arg3, arg4) -> SSLSocketInitiatorBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"arg4: FIX::LogFactory &\n"
		"\n"
		""},
	 { "delete_SSLSocketInitiatorBase", _wrap_delete_SSLSocketInitiatorBase, METH_O, "delete_SSLSocketInitiatorBase(self)"},
	 { "SSLSocketInitiatorBase_setPassword", _wrap_SSLSocketInitiatorBase_setPassword, METH_VARARGS, "\n"
		"SSLSocketInitiatorBase_setPassword(self, pwd)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pwd: std::string const &\n"
		"\n"
		""},
	 { "SSLSocketInitiatorBase_setCertAndKey", _wrap_SSLSocketInitiatorBase_setCertAndKey, METH_VARARGS, "\n"
		"SSLSocketInitiatorBase_setCertAndKey(self, cert, key)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"cert: X509 *\n"
		"key: RSA *\n"
		"\n"
		""},
	 { "SSLSocketInitiatorBase_passwordHandleCallback", _wrap_SSLSocketInitiatorBase_passwordHandleCallback, METH_VARARGS, "\n"
		"SSLSocketInitiatorBase_passwordHandleCallback(self, buf, bufsize, verify) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"buf: char *\n"
		"bufsize: size_t\n"
		"verify: int\n"
		"\n"
		""},
	 { "SSLSocketInitiatorBase_passwordHandleCB", _wrap_SSLSocketInitiatorBase_passwordHandleCB, METH_VARARGS, "\n"
		"SSLSocketInitiatorBase_passwordHandleCB(buf, bufsize, verify, instance) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"buf: char *\n"
		"bufsize: int\n"
		"verify: int\n"
		"instance: void *\n"
		"\n"
		""},
	 { "SSLSocketInitiatorBase_swigregister", SSLSocketInitiatorBase_swigregister, METH_O, NULL},
	 { "SSLSocketInitiatorBase_swiginit", SSLSocketInitiatorBase_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseConnectionID", _wrap_new_DatabaseConnectionID, METH_VARARGS, "\n"
		"new_DatabaseConnectionID(database, user, password, host, port) -> DatabaseConnectionID\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		""},
	 { "__lt__", _wrap___lt__, METH_VARARGS, "\n"
		"__lt__(lhs, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::DateTime const &\n"
		"rhs: FIX::DateTime const &\n"
		"\n"
		"__lt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: char const *\n"
		"\n"
		"__lt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: char const *\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__lt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: std::string const &\n"
		"\n"
		"__lt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::string const &\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__lt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		"__lt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::DatabaseConnectionID const &\n"
		"arg2: FIX::DatabaseConnectionID const &\n"
		"\n"
		""},
	 { "__eq__", _wrap___eq__, METH_VARARGS, "\n"
		"__eq__(lhs, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::DateTime const &\n"
		"rhs: FIX::DateTime const &\n"
		"\n"
		"__eq__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: char const *\n"
		"\n"
		"__eq__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: char const *\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__eq__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: std::string const &\n"
		"\n"
		"__eq__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::string const &\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__eq__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		"__eq__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::DatabaseConnectionID const &\n"
		"arg2: FIX::DatabaseConnectionID const &\n"
		"\n"
		""},
	 { "__ne__", _wrap___ne__, METH_VARARGS, "\n"
		"__ne__(lhs, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::DateTime const &\n"
		"rhs: FIX::DateTime const &\n"
		"\n"
		"__ne__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: char const *\n"
		"\n"
		"__ne__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: char const *\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__ne__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: std::string const &\n"
		"\n"
		"__ne__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::string const &\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__ne__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		"__ne__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::DatabaseConnectionID const &\n"
		"arg2: FIX::DatabaseConnectionID const &\n"
		"\n"
		""},
	 { "DatabaseConnectionID_getDatabase", _wrap_DatabaseConnectionID_getDatabase, METH_O, "DatabaseConnectionID_getDatabase(self) -> std::string const &"},
	 { "DatabaseConnectionID_getUser", _wrap_DatabaseConnectionID_getUser, METH_O, "DatabaseConnectionID_getUser(self) -> std::string const &"},
	 { "DatabaseConnectionID_getPassword", _wrap_DatabaseConnectionID_getPassword, METH_O, "DatabaseConnectionID_getPassword(self) -> std::string const &"},
	 { "DatabaseConnectionID_getHost", _wrap_DatabaseConnectionID_getHost, METH_O, "DatabaseConnectionID_getHost(self) -> std::string const &"},
	 { "DatabaseConnectionID_getPort", _wrap_DatabaseConnectionID_getPort, METH_O, "DatabaseConnectionID_getPort(self) -> short"},
	 { "delete_DatabaseConnectionID", _wrap_delete_DatabaseConnectionID, METH_O, "delete_DatabaseConnectionID(self)"},
	 { "DatabaseConnectionID_swigregister", DatabaseConnectionID_swigregister, METH_O, NULL},
	 { "DatabaseConnectionID_swiginit", DatabaseConnectionID_swiginit, METH_VARARGS, NULL},
	 { "new_MySQLQuery", _wrap_new_MySQLQuery, METH_O, "\n"
		"new_MySQLQuery(query) -> MySQLQuery\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"query: std::string const &\n"
		"\n"
		""},
	 { "delete_MySQLQuery", _wrap_delete_MySQLQuery, METH_O, "delete_MySQLQuery(self)"},
	 { "MySQLQuery_execute", _wrap_MySQLQuery_execute, METH_VARARGS, "\n"
		"MySQLQuery_execute(self, pConnection) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pConnection: MYSQL *\n"
		"\n"
		""},
	 { "MySQLQuery_success", _wrap_MySQLQuery_success, METH_O, "MySQLQuery_success(self) -> bool"},
	 { "MySQLQuery_rows", _wrap_MySQLQuery_rows, METH_O, "MySQLQuery_rows(self) -> int"},
	 { "MySQLQuery_reason", _wrap_MySQLQuery_reason, METH_O, "MySQLQuery_reason(self) -> std::string const &"},
	 { "MySQLQuery_getValue", _wrap_MySQLQuery_getValue, METH_VARARGS, "\n"
		"MySQLQuery_getValue(self, row, column) -> char *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"row: int\n"
		"column: int\n"
		"\n"
		""},
	 { "MySQLQuery_throwException", _wrap_MySQLQuery_throwException, METH_O, "MySQLQuery_throwException(self)"},
	 { "MySQLQuery_swigregister", MySQLQuery_swigregister, METH_O, NULL},
	 { "MySQLQuery_swiginit", MySQLQuery_swiginit, METH_VARARGS, NULL},
	 { "new_MySQLConnection", _wrap_new_MySQLConnection, METH_VARARGS, "\n"
		"MySQLConnection(id)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id: FIX::DatabaseConnectionID const &\n"
		"\n"
		"new_MySQLConnection(database, user, password, host, port) -> MySQLConnection\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		""},
	 { "delete_MySQLConnection", _wrap_delete_MySQLConnection, METH_O, "delete_MySQLConnection(self)"},
	 { "MySQLConnection_connectionID", _wrap_MySQLConnection_connectionID, METH_O, "MySQLConnection_connectionID(self) -> DatabaseConnectionID"},
	 { "MySQLConnection_connected", _wrap_MySQLConnection_connected, METH_O, "MySQLConnection_connected(self) -> bool"},
	 { "MySQLConnection_reconnect", _wrap_MySQLConnection_reconnect, METH_O, "MySQLConnection_reconnect(self) -> bool"},
	 { "MySQLConnection_execute", _wrap_MySQLConnection_execute, METH_VARARGS, "\n"
		"MySQLConnection_execute(self, pQuery) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pQuery: FIX::MySQLQuery &\n"
		"\n"
		""},
	 { "MySQLConnection_swigregister", MySQLConnection_swigregister, METH_O, NULL},
	 { "MySQLConnection_swiginit", MySQLConnection_swiginit, METH_VARARGS, NULL},
	 { "new_MySQLStoreFactory", _wrap_new_MySQLStoreFactory, METH_VARARGS, "\n"
		"MySQLStoreFactory(settings)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"settings: FIX::SessionSettings const &\n"
		"\n"
		"MySQLStoreFactory(dictionary)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dictionary: FIX::Dictionary const &\n"
		"\n"
		"MySQLStoreFactory(database, user, password, host, port)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		"new_MySQLStoreFactory() -> MySQLStoreFactory\n"
		""},
	 { "MySQLStoreFactory_create", _wrap_MySQLStoreFactory_create, METH_VARARGS, "\n"
		"MySQLStoreFactory_create(self, arg2, arg3) -> MessageStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::UtcTimeStamp const &\n"
		"arg3: FIX::SessionID const &\n"
		"\n"
		""},
	 { "MySQLStoreFactory_destroy", _wrap_MySQLStoreFactory_destroy, METH_VARARGS, "\n"
		"MySQLStoreFactory_destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::MessageStore *\n"
		"\n"
		""},
	 { "delete_MySQLStoreFactory", _wrap_delete_MySQLStoreFactory, METH_O, "delete_MySQLStoreFactory(self)"},
	 { "MySQLStoreFactory_swigregister", MySQLStoreFactory_swigregister, METH_O, NULL},
	 { "MySQLStoreFactory_swiginit", MySQLStoreFactory_swiginit, METH_VARARGS, NULL},
	 { "new_MySQLStore", _wrap_new_MySQLStore, METH_VARARGS, "\n"
		"MySQLStore(now, sessionID, connection, pool)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"sessionID: FIX::SessionID const &\n"
		"connection: FIX::DatabaseConnectionID const &\n"
		"pool: FIX::MySQLConnectionPool *\n"
		"\n"
		"new_MySQLStore(now, sessionID, database, user, password, host, port) -> MySQLStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"sessionID: FIX::SessionID const &\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		""},
	 { "delete_MySQLStore", _wrap_delete_MySQLStore, METH_O, "delete_MySQLStore(self)"},
	 { "MySQLStore_set", _wrap_MySQLStore_set, METH_VARARGS, "\n"
		"MySQLStore_set(self, arg2, arg3) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: std::string const &\n"
		"\n"
		""},
	 { "MySQLStore_get", _wrap_MySQLStore_get, METH_VARARGS, "\n"
		"MySQLStore_get(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: FIX::SEQNUM\n"
		"arg4: std::vector< std::string,std::allocator< std::string > > &\n"
		"\n"
		""},
	 { "MySQLStore_getNextSenderMsgSeqNum", _wrap_MySQLStore_getNextSenderMsgSeqNum, METH_O, "MySQLStore_getNextSenderMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "MySQLStore_getNextTargetMsgSeqNum", _wrap_MySQLStore_getNextTargetMsgSeqNum, METH_O, "MySQLStore_getNextTargetMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "MySQLStore_setNextSenderMsgSeqNum", _wrap_MySQLStore_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"MySQLStore_setNextSenderMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "MySQLStore_setNextTargetMsgSeqNum", _wrap_MySQLStore_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"MySQLStore_setNextTargetMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "MySQLStore_incrNextSenderMsgSeqNum", _wrap_MySQLStore_incrNextSenderMsgSeqNum, METH_O, "MySQLStore_incrNextSenderMsgSeqNum(self)"},
	 { "MySQLStore_incrNextTargetMsgSeqNum", _wrap_MySQLStore_incrNextTargetMsgSeqNum, METH_O, "MySQLStore_incrNextTargetMsgSeqNum(self)"},
	 { "MySQLStore_getCreationTime", _wrap_MySQLStore_getCreationTime, METH_O, "MySQLStore_getCreationTime(self) -> UtcTimeStamp"},
	 { "MySQLStore_reset", _wrap_MySQLStore_reset, METH_VARARGS, "\n"
		"MySQLStore_reset(self, now)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "MySQLStore_refresh", _wrap_MySQLStore_refresh, METH_O, "MySQLStore_refresh(self)"},
	 { "MySQLStore_swigregister", MySQLStore_swigregister, METH_O, NULL},
	 { "MySQLStore_swiginit", MySQLStore_swiginit, METH_VARARGS, NULL},
	 { "new_MySQLLog", _wrap_new_MySQLLog, METH_VARARGS, "\n"
		"MySQLLog(sessionID, connectionID, pool)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"connectionID: FIX::DatabaseConnectionID const &\n"
		"pool: FIX::MySQLConnectionPool *\n"
		"\n"
		"MySQLLog(connectionID, pool)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"connectionID: FIX::DatabaseConnectionID const &\n"
		"pool: FIX::MySQLConnectionPool *\n"
		"\n"
		"MySQLLog(sessionID, database, user, password, host, port)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		"new_MySQLLog(database, user, password, host, port) -> MySQLLog\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		""},
	 { "delete_MySQLLog", _wrap_delete_MySQLLog, METH_O, "delete_MySQLLog(self)"},
	 { "MySQLLog_clear", _wrap_MySQLLog_clear, METH_O, "MySQLLog_clear(self)"},
	 { "MySQLLog_backup", _wrap_MySQLLog_backup, METH_O, "MySQLLog_backup(self)"},
	 { "MySQLLog_setIncomingTable", _wrap_MySQLLog_setIncomingTable, METH_VARARGS, "\n"
		"MySQLLog_setIncomingTable(self, incomingTable)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"incomingTable: std::string const &\n"
		"\n"
		""},
	 { "MySQLLog_setOutgoingTable", _wrap_MySQLLog_setOutgoingTable, METH_VARARGS, "\n"
		"MySQLLog_setOutgoingTable(self, outgoingTable)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"outgoingTable: std::string const &\n"
		"\n"
		""},
	 { "MySQLLog_setEventTable", _wrap_MySQLLog_setEventTable, METH_VARARGS, "\n"
		"MySQLLog_setEventTable(self, eventTable)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eventTable: std::string const &\n"
		"\n"
		""},
	 { "MySQLLog_onIncoming", _wrap_MySQLLog_onIncoming, METH_VARARGS, "\n"
		"MySQLLog_onIncoming(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "MySQLLog_onOutgoing", _wrap_MySQLLog_onOutgoing, METH_VARARGS, "\n"
		"MySQLLog_onOutgoing(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "MySQLLog_onEvent", _wrap_MySQLLog_onEvent, METH_VARARGS, "\n"
		"MySQLLog_onEvent(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "MySQLLog_swigregister", MySQLLog_swigregister, METH_O, NULL},
	 { "MySQLLog_swiginit", MySQLLog_swiginit, METH_VARARGS, NULL},
	 { "new_MySQLLogFactory", _wrap_new_MySQLLogFactory, METH_VARARGS, "\n"
		"MySQLLogFactory(settings)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"settings: FIX::SessionSettings const &\n"
		"\n"
		"MySQLLogFactory(database, user, password, host, port)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		"new_MySQLLogFactory() -> MySQLLogFactory\n"
		""},
	 { "MySQLLogFactory_create", _wrap_MySQLLogFactory_create, METH_VARARGS, "\n"
		"MySQLLogFactory_create(self) -> Log\n"
		"MySQLLogFactory_create(self, arg2) -> Log\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		""},
	 { "MySQLLogFactory_destroy", _wrap_MySQLLogFactory_destroy, METH_VARARGS, "\n"
		"MySQLLogFactory_destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::Log *\n"
		"\n"
		""},
	 { "delete_MySQLLogFactory", _wrap_delete_MySQLLogFactory, METH_O, "delete_MySQLLogFactory(self)"},
	 { "MySQLLogFactory_swigregister", MySQLLogFactory_swigregister, METH_O, NULL},
	 { "MySQLLogFactory_swiginit", MySQLLogFactory_swiginit, METH_VARARGS, NULL},
	 { "new_PostgreSQLQuery", _wrap_new_PostgreSQLQuery, METH_O, "\n"
		"new_PostgreSQLQuery(query) -> PostgreSQLQuery\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"query: std::string const &\n"
		"\n"
		""},
	 { "delete_PostgreSQLQuery", _wrap_delete_PostgreSQLQuery, METH_O, "delete_PostgreSQLQuery(self)"},
	 { "PostgreSQLQuery_execute", _wrap_PostgreSQLQuery_execute, METH_VARARGS, "\n"
		"PostgreSQLQuery_execute(self, pConnection) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pConnection: PGconn *\n"
		"\n"
		""},
	 { "PostgreSQLQuery_success", _wrap_PostgreSQLQuery_success, METH_O, "PostgreSQLQuery_success(self) -> bool"},
	 { "PostgreSQLQuery_rows", _wrap_PostgreSQLQuery_rows, METH_O, "PostgreSQLQuery_rows(self) -> int"},
	 { "PostgreSQLQuery_reason", _wrap_PostgreSQLQuery_reason, METH_O, "PostgreSQLQuery_reason(self) -> char *"},
	 { "PostgreSQLQuery_getValue", _wrap_PostgreSQLQuery_getValue, METH_VARARGS, "\n"
		"PostgreSQLQuery_getValue(self, row, column) -> char *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"row: int\n"
		"column: int\n"
		"\n"
		""},
	 { "PostgreSQLQuery_throwException", _wrap_PostgreSQLQuery_throwException, METH_O, "PostgreSQLQuery_throwException(self)"},
	 { "PostgreSQLQuery_swigregister", PostgreSQLQuery_swigregister, METH_O, NULL},
	 { "PostgreSQLQuery_swiginit", PostgreSQLQuery_swiginit, METH_VARARGS, NULL},
	 { "new_PostgreSQLConnection", _wrap_new_PostgreSQLConnection, METH_VARARGS, "\n"
		"PostgreSQLConnection(id)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id: FIX::DatabaseConnectionID const &\n"
		"\n"
		"new_PostgreSQLConnection(database, user, password, host, port) -> PostgreSQLConnection\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		""},
	 { "delete_PostgreSQLConnection", _wrap_delete_PostgreSQLConnection, METH_O, "delete_PostgreSQLConnection(self)"},
	 { "PostgreSQLConnection_connectionID", _wrap_PostgreSQLConnection_connectionID, METH_O, "PostgreSQLConnection_connectionID(self) -> DatabaseConnectionID"},
	 { "PostgreSQLConnection_connected", _wrap_PostgreSQLConnection_connected, METH_O, "PostgreSQLConnection_connected(self) -> bool"},
	 { "PostgreSQLConnection_reconnect", _wrap_PostgreSQLConnection_reconnect, METH_O, "PostgreSQLConnection_reconnect(self) -> bool"},
	 { "PostgreSQLConnection_execute", _wrap_PostgreSQLConnection_execute, METH_VARARGS, "\n"
		"PostgreSQLConnection_execute(self, pQuery) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pQuery: FIX::PostgreSQLQuery &\n"
		"\n"
		""},
	 { "PostgreSQLConnection_swigregister", PostgreSQLConnection_swigregister, METH_O, NULL},
	 { "PostgreSQLConnection_swiginit", PostgreSQLConnection_swiginit, METH_VARARGS, NULL},
	 { "new_PostgreSQLStoreFactory", _wrap_new_PostgreSQLStoreFactory, METH_VARARGS, "\n"
		"PostgreSQLStoreFactory(settings)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"settings: FIX::SessionSettings const &\n"
		"\n"
		"PostgreSQLStoreFactory(dictionary)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dictionary: FIX::Dictionary const &\n"
		"\n"
		"PostgreSQLStoreFactory(database, user, password, host, port)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		"new_PostgreSQLStoreFactory() -> PostgreSQLStoreFactory\n"
		""},
	 { "PostgreSQLStoreFactory_create", _wrap_PostgreSQLStoreFactory_create, METH_VARARGS, "\n"
		"PostgreSQLStoreFactory_create(self, arg2, arg3) -> MessageStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::UtcTimeStamp const &\n"
		"arg3: FIX::SessionID const &\n"
		"\n"
		""},
	 { "PostgreSQLStoreFactory_destroy", _wrap_PostgreSQLStoreFactory_destroy, METH_VARARGS, "\n"
		"PostgreSQLStoreFactory_destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::MessageStore *\n"
		"\n"
		""},
	 { "delete_PostgreSQLStoreFactory", _wrap_delete_PostgreSQLStoreFactory, METH_O, "delete_PostgreSQLStoreFactory(self)"},
	 { "PostgreSQLStoreFactory_swigregister", PostgreSQLStoreFactory_swigregister, METH_O, NULL},
	 { "PostgreSQLStoreFactory_swiginit", PostgreSQLStoreFactory_swiginit, METH_VARARGS, NULL},
	 { "new_PostgreSQLStore", _wrap_new_PostgreSQLStore, METH_VARARGS, "\n"
		"PostgreSQLStore(now, sessionID, connection, pool)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"sessionID: FIX::SessionID const &\n"
		"connection: FIX::DatabaseConnectionID const &\n"
		"pool: FIX::PostgreSQLConnectionPool *\n"
		"\n"
		"new_PostgreSQLStore(now, sessionID, database, user, password, host, port) -> PostgreSQLStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"sessionID: FIX::SessionID const &\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		""},
	 { "delete_PostgreSQLStore", _wrap_delete_PostgreSQLStore, METH_O, "delete_PostgreSQLStore(self)"},
	 { "PostgreSQLStore_set", _wrap_PostgreSQLStore_set, METH_VARARGS, "\n"
		"PostgreSQLStore_set(self, arg2, arg3) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: std::string const &\n"
		"\n"
		""},
	 { "PostgreSQLStore_get", _wrap_PostgreSQLStore_get, METH_VARARGS, "\n"
		"PostgreSQLStore_get(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: FIX::SEQNUM\n"
		"arg4: std::vector< std::string,std::allocator< std::string > > &\n"
		"\n"
		""},
	 { "PostgreSQLStore_getNextSenderMsgSeqNum", _wrap_PostgreSQLStore_getNextSenderMsgSeqNum, METH_O, "PostgreSQLStore_getNextSenderMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "PostgreSQLStore_getNextTargetMsgSeqNum", _wrap_PostgreSQLStore_getNextTargetMsgSeqNum, METH_O, "PostgreSQLStore_getNextTargetMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "PostgreSQLStore_setNextSenderMsgSeqNum", _wrap_PostgreSQLStore_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"PostgreSQLStore_setNextSenderMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "PostgreSQLStore_setNextTargetMsgSeqNum", _wrap_PostgreSQLStore_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"PostgreSQLStore_setNextTargetMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "PostgreSQLStore_incrNextSenderMsgSeqNum", _wrap_PostgreSQLStore_incrNextSenderMsgSeqNum, METH_O, "PostgreSQLStore_incrNextSenderMsgSeqNum(self)"},
	 { "PostgreSQLStore_incrNextTargetMsgSeqNum", _wrap_PostgreSQLStore_incrNextTargetMsgSeqNum, METH_O, "PostgreSQLStore_incrNextTargetMsgSeqNum(self)"},
	 { "PostgreSQLStore_getCreationTime", _wrap_PostgreSQLStore_getCreationTime, METH_O, "PostgreSQLStore_getCreationTime(self) -> UtcTimeStamp"},
	 { "PostgreSQLStore_reset", _wrap_PostgreSQLStore_reset, METH_VARARGS, "\n"
		"PostgreSQLStore_reset(self, now)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "PostgreSQLStore_refresh", _wrap_PostgreSQLStore_refresh, METH_O, "PostgreSQLStore_refresh(self)"},
	 { "PostgreSQLStore_swigregister", PostgreSQLStore_swigregister, METH_O, NULL},
	 { "PostgreSQLStore_swiginit", PostgreSQLStore_swiginit, METH_VARARGS, NULL},
	 { "new_PostgreSQLLog", _wrap_new_PostgreSQLLog, METH_VARARGS, "\n"
		"PostgreSQLLog(s, d, p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"s: FIX::SessionID const &\n"
		"d: FIX::DatabaseConnectionID const &\n"
		"p: FIX::PostgreSQLConnectionPool *\n"
		"\n"
		"PostgreSQLLog(d, p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"d: FIX::DatabaseConnectionID const &\n"
		"p: FIX::PostgreSQLConnectionPool *\n"
		"\n"
		"PostgreSQLLog(s, database, user, password, host, port)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"s: FIX::SessionID const &\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		"new_PostgreSQLLog(database, user, password, host, port) -> PostgreSQLLog\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		""},
	 { "delete_PostgreSQLLog", _wrap_delete_PostgreSQLLog, METH_O, "delete_PostgreSQLLog(self)"},
	 { "PostgreSQLLog_clear", _wrap_PostgreSQLLog_clear, METH_O, "PostgreSQLLog_clear(self)"},
	 { "PostgreSQLLog_backup", _wrap_PostgreSQLLog_backup, METH_O, "PostgreSQLLog_backup(self)"},
	 { "PostgreSQLLog_setIncomingTable", _wrap_PostgreSQLLog_setIncomingTable, METH_VARARGS, "\n"
		"PostgreSQLLog_setIncomingTable(self, incomingTable)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"incomingTable: std::string const &\n"
		"\n"
		""},
	 { "PostgreSQLLog_setOutgoingTable", _wrap_PostgreSQLLog_setOutgoingTable, METH_VARARGS, "\n"
		"PostgreSQLLog_setOutgoingTable(self, outgoingTable)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"outgoingTable: std::string const &\n"
		"\n"
		""},
	 { "PostgreSQLLog_setEventTable", _wrap_PostgreSQLLog_setEventTable, METH_VARARGS, "\n"
		"PostgreSQLLog_setEventTable(self, eventTable)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eventTable: std::string const &\n"
		"\n"
		""},
	 { "PostgreSQLLog_onIncoming", _wrap_PostgreSQLLog_onIncoming, METH_VARARGS, "\n"
		"PostgreSQLLog_onIncoming(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "PostgreSQLLog_onOutgoing", _wrap_PostgreSQLLog_onOutgoing, METH_VARARGS, "\n"
		"PostgreSQLLog_onOutgoing(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "PostgreSQLLog_onEvent", _wrap_PostgreSQLLog_onEvent, METH_VARARGS, "\n"
		"PostgreSQLLog_onEvent(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "PostgreSQLLog_swigregister", PostgreSQLLog_swigregister, METH_O, NULL},
	 { "PostgreSQLLog_swiginit", PostgreSQLLog_swiginit, METH_VARARGS, NULL},
	 { "new_PostgreSQLLogFactory", _wrap_new_PostgreSQLLogFactory, METH_VARARGS, "\n"
		"PostgreSQLLogFactory(settings)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"settings: FIX::SessionSettings const &\n"
		"\n"
		"PostgreSQLLogFactory(database, user, password, host, port)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		"new_PostgreSQLLogFactory() -> PostgreSQLLogFactory\n"
		""},
	 { "PostgreSQLLogFactory_create", _wrap_PostgreSQLLogFactory_create, METH_VARARGS, "\n"
		"PostgreSQLLogFactory_create(self) -> Log\n"
		"PostgreSQLLogFactory_create(self, arg2) -> Log\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		""},
	 { "PostgreSQLLogFactory_destroy", _wrap_PostgreSQLLogFactory_destroy, METH_VARARGS, "\n"
		"PostgreSQLLogFactory_destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::Log *\n"
		"\n"
		""},
	 { "delete_PostgreSQLLogFactory", _wrap_delete_PostgreSQLLogFactory, METH_O, "delete_PostgreSQLLogFactory(self)"},
	 { "PostgreSQLLogFactory_swigregister", PostgreSQLLogFactory_swigregister, METH_O, NULL},
	 { "PostgreSQLLogFactory_swiginit", PostgreSQLLogFactory_swiginit, METH_VARARGS, NULL},
	 { "new_ThreadedSocketAcceptorBase", _wrap_new_ThreadedSocketAcceptorBase, METH_VARARGS, "\n"
		"ThreadedSocketAcceptor(arg1, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"\n"
		"new_ThreadedSocketAcceptorBase(arg1, arg2, arg3, arg4) -> ThreadedSocketAcceptorBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"arg4: FIX::LogFactory &\n"
		"\n"
		""},
	 { "delete_ThreadedSocketAcceptorBase", _wrap_delete_ThreadedSocketAcceptorBase, METH_O, "delete_ThreadedSocketAcceptorBase(self)"},
	 { "ThreadedSocketAcceptorBase_swigregister", ThreadedSocketAcceptorBase_swigregister, METH_O, NULL},
	 { "ThreadedSocketAcceptorBase_swiginit", ThreadedSocketAcceptorBase_swiginit, METH_VARARGS, NULL},
	 { "new_ThreadedSocketInitiatorBase", _wrap_new_ThreadedSocketInitiatorBase, METH_VARARGS, "\n"
		"ThreadedSocketInitiator(arg1, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"\n"
		"new_ThreadedSocketInitiatorBase(arg1, arg2, arg3, arg4) -> ThreadedSocketInitiatorBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"arg4: FIX::LogFactory &\n"
		"\n"
		""},
	 { "delete_ThreadedSocketInitiatorBase", _wrap_delete_ThreadedSocketInitiatorBase, METH_O, "delete_ThreadedSocketInitiatorBase(self)"},
	 { "ThreadedSocketInitiatorBase_swigregister", ThreadedSocketInitiatorBase_swigregister, METH_O, NULL},
	 { "ThreadedSocketInitiatorBase_swiginit", ThreadedSocketInitiatorBase_swiginit, METH_VARARGS, NULL},
	 { "NullStoreFactory_create", _wrap_NullStoreFactory_create, METH_VARARGS, "\n"
		"NullStoreFactory_create(self, arg2, arg3) -> MessageStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::UtcTimeStamp const &\n"
		"arg3: FIX::SessionID const &\n"
		"\n"
		""},
	 { "NullStoreFactory_destroy", _wrap_NullStoreFactory_destroy, METH_VARARGS, "\n"
		"NullStoreFactory_destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::MessageStore *\n"
		"\n"
		""},
	 { "new_NullStoreFactory", _wrap_new_NullStoreFactory, METH_NOARGS, "new_NullStoreFactory() -> NullStoreFactory"},
	 { "delete_NullStoreFactory", _wrap_delete_NullStoreFactory, METH_O, "delete_NullStoreFactory(self)"},
	 { "NullStoreFactory_swigregister", NullStoreFactory_swigregister, METH_O, NULL},
	 { "NullStoreFactory_swiginit", NullStoreFactory_swiginit, METH_VARARGS, NULL},
	 { "new_NullStore", _wrap_new_NullStore, METH_O, "\n"
		"new_NullStore(now) -> NullStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "NullStore_set", _wrap_NullStore_set, METH_VARARGS, "\n"
		"NullStore_set(self, arg2, arg3) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: std::string const &\n"
		"\n"
		""},
	 { "NullStore_get", _wrap_NullStore_get, METH_VARARGS, "\n"
		"NullStore_get(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: FIX::SEQNUM\n"
		"arg4: std::vector< std::string,std::allocator< std::string > > &\n"
		"\n"
		""},
	 { "NullStore_getNextSenderMsgSeqNum", _wrap_NullStore_getNextSenderMsgSeqNum, METH_O, "NullStore_getNextSenderMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "NullStore_getNextTargetMsgSeqNum", _wrap_NullStore_getNextTargetMsgSeqNum, METH_O, "NullStore_getNextTargetMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "NullStore_setNextSenderMsgSeqNum", _wrap_NullStore_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"NullStore_setNextSenderMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "NullStore_setNextTargetMsgSeqNum", _wrap_NullStore_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"NullStore_setNextTargetMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "NullStore_incrNextSenderMsgSeqNum", _wrap_NullStore_incrNextSenderMsgSeqNum, METH_O, "NullStore_incrNextSenderMsgSeqNum(self)"},
	 { "NullStore_incrNextTargetMsgSeqNum", _wrap_NullStore_incrNextTargetMsgSeqNum, METH_O, "NullStore_incrNextTargetMsgSeqNum(self)"},
	 { "NullStore_setCreationTime", _wrap_NullStore_setCreationTime, METH_VARARGS, "\n"
		"NullStore_setCreationTime(self, creationTime)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"creationTime: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "NullStore_getCreationTime", _wrap_NullStore_getCreationTime, METH_O, "NullStore_getCreationTime(self) -> UtcTimeStamp"},
	 { "NullStore_reset", _wrap_NullStore_reset, METH_VARARGS, "\n"
		"NullStore_reset(self, now)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "NullStore_refresh", _wrap_NullStore_refresh, METH_O, "NullStore_refresh(self)"},
	 { "delete_NullStore", _wrap_delete_NullStore, METH_O, "delete_NullStore(self)"},
	 { "NullStore_swigregister", NullStore_swigregister, METH_O, NULL},
	 { "NullStore_swiginit", NullStore_swiginit, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};

static PyMethodDef SwigMethods_proxydocs[] = {
	 { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL},
	 { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, "delete_SwigPyIterator(self)"},
	 { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, "value(self) -> PyObject *"},
	 { "SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, "\n"
		"incr(self, n=1) -> SwigPyIterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: size_t\n"
		"\n"
		""},
	 { "SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, "\n"
		"decr(self, n=1) -> SwigPyIterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: size_t\n"
		"\n"
		""},
	 { "SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, "\n"
		"distance(self, x) -> ptrdiff_t\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: swig::SwigPyIterator const &\n"
		"\n"
		""},
	 { "SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, "\n"
		"equal(self, x) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: swig::SwigPyIterator const &\n"
		"\n"
		""},
	 { "SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_O, "copy(self) -> SwigPyIterator"},
	 { "SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_O, "next(self) -> PyObject *"},
	 { "SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_O, "__next__(self) -> PyObject *"},
	 { "SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_O, "previous(self) -> PyObject *"},
	 { "SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, "\n"
		"advance(self, n) -> SwigPyIterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: ptrdiff_t\n"
		"\n"
		""},
	 { "SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, "\n"
		"__eq__(self, x) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: swig::SwigPyIterator const &\n"
		"\n"
		""},
	 { "SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, "\n"
		"__ne__(self, x) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: swig::SwigPyIterator const &\n"
		"\n"
		""},
	 { "SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, "\n"
		"__iadd__(self, n) -> SwigPyIterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: ptrdiff_t\n"
		"\n"
		""},
	 { "SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, "\n"
		"__isub__(self, n) -> SwigPyIterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: ptrdiff_t\n"
		"\n"
		""},
	 { "SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, "\n"
		"__add__(self, n) -> SwigPyIterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: ptrdiff_t\n"
		"\n"
		""},
	 { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, "\n"
		"__sub__(self, n) -> SwigPyIterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: ptrdiff_t\n"
		"\n"
		"__sub__(self, x) -> ptrdiff_t\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: swig::SwigPyIterator const &\n"
		"\n"
		""},
	 { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
	 { "VectorString_iterator", _wrap_VectorString_iterator, METH_O, "iterator(self) -> SwigPyIterator"},
	 { "VectorString___nonzero__", _wrap_VectorString___nonzero__, METH_O, "__nonzero__(self) -> bool"},
	 { "VectorString___bool__", _wrap_VectorString___bool__, METH_O, "__bool__(self) -> bool"},
	 { "VectorString___len__", _wrap_VectorString___len__, METH_O, "__len__(self) -> std::vector< std::string >::size_type"},
	 { "VectorString___getslice__", _wrap_VectorString___getslice__, METH_VARARGS, "\n"
		"__getslice__(self, i, j) -> VectorString\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::vector< std::string >::difference_type\n"
		"j: std::vector< std::string >::difference_type\n"
		"\n"
		""},
	 { "VectorString___setslice__", _wrap_VectorString___setslice__, METH_VARARGS, "\n"
		"__setslice__(self, i, j)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::vector< std::string >::difference_type\n"
		"j: std::vector< std::string >::difference_type\n"
		"\n"
		"__setslice__(self, i, j, v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::vector< std::string >::difference_type\n"
		"j: std::vector< std::string >::difference_type\n"
		"v: std::vector< std::string,std::allocator< std::string > > const &\n"
		"\n"
		""},
	 { "VectorString___delslice__", _wrap_VectorString___delslice__, METH_VARARGS, "\n"
		"__delslice__(self, i, j)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::vector< std::string >::difference_type\n"
		"j: std::vector< std::string >::difference_type\n"
		"\n"
		""},
	 { "VectorString___delitem__", _wrap_VectorString___delitem__, METH_VARARGS, "\n"
		"__delitem__(self, i)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::vector< std::string >::difference_type\n"
		"\n"
		"__delitem__(self, slice)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"slice: PySliceObject *\n"
		"\n"
		""},
	 { "VectorString___getitem__", _wrap_VectorString___getitem__, METH_VARARGS, "\n"
		"__getitem__(self, slice) -> VectorString\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"slice: PySliceObject *\n"
		"\n"
		"__getitem__(self, i) -> std::vector< std::string >::value_type const &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::vector< std::string >::difference_type\n"
		"\n"
		""},
	 { "VectorString___setitem__", _wrap_VectorString___setitem__, METH_VARARGS, "\n"
		"__setitem__(self, slice, v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"slice: PySliceObject *\n"
		"v: std::vector< std::string,std::allocator< std::string > > const &\n"
		"\n"
		"__setitem__(self, slice)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"slice: PySliceObject *\n"
		"\n"
		"__setitem__(self, i, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::vector< std::string >::difference_type\n"
		"x: std::vector< std::string >::value_type const &\n"
		"\n"
		""},
	 { "VectorString_pop", _wrap_VectorString_pop, METH_O, "pop(self) -> std::vector< std::string >::value_type"},
	 { "VectorString_append", _wrap_VectorString_append, METH_VARARGS, "\n"
		"append(self, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::vector< std::string >::value_type const &\n"
		"\n"
		""},
	 { "VectorString_empty", _wrap_VectorString_empty, METH_O, "empty(self) -> bool"},
	 { "VectorString_size", _wrap_VectorString_size, METH_O, "size(self) -> std::vector< std::string >::size_type"},
	 { "VectorString_swap", _wrap_VectorString_swap, METH_VARARGS, "\n"
		"swap(self, v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v: std::vector< std::string > &\n"
		"\n"
		""},
	 { "VectorString_begin", _wrap_VectorString_begin, METH_O, "begin(self) -> std::vector< std::string >::iterator"},
	 { "VectorString_end", _wrap_VectorString_end, METH_O, "end(self) -> std::vector< std::string >::iterator"},
	 { "VectorString_rbegin", _wrap_VectorString_rbegin, METH_O, "rbegin(self) -> std::vector< std::string >::reverse_iterator"},
	 { "VectorString_rend", _wrap_VectorString_rend, METH_O, "rend(self) -> std::vector< std::string >::reverse_iterator"},
	 { "VectorString_clear", _wrap_VectorString_clear, METH_O, "clear(self)"},
	 { "VectorString_get_allocator", _wrap_VectorString_get_allocator, METH_O, "get_allocator(self) -> std::vector< std::string >::allocator_type"},
	 { "VectorString_pop_back", _wrap_VectorString_pop_back, METH_O, "pop_back(self)"},
	 { "VectorString_erase", _wrap_VectorString_erase, METH_VARARGS, "\n"
		"erase(self, pos) -> std::vector< std::string >::iterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pos: std::vector< std::string >::iterator\n"
		"\n"
		"erase(self, first, last) -> std::vector< std::string >::iterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"first: std::vector< std::string >::iterator\n"
		"last: std::vector< std::string >::iterator\n"
		"\n"
		""},
	 { "new_VectorString", _wrap_new_VectorString, METH_VARARGS, "\n"
		"VectorString()\n"
		"VectorString(other)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"other: std::vector< std::string > const &\n"
		"\n"
		"VectorString(size)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"size: std::vector< std::string >::size_type\n"
		"\n"
		"new_VectorString(size, value) -> VectorString\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"size: std::vector< std::string >::size_type\n"
		"value: std::vector< std::string >::value_type const &\n"
		"\n"
		""},
	 { "VectorString_push_back", _wrap_VectorString_push_back, METH_VARARGS, "\n"
		"push_back(self, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::vector< std::string >::value_type const &\n"
		"\n"
		""},
	 { "VectorString_front", _wrap_VectorString_front, METH_O, "front(self) -> std::vector< std::string >::value_type const &"},
	 { "VectorString_back", _wrap_VectorString_back, METH_O, "back(self) -> std::vector< std::string >::value_type const &"},
	 { "VectorString_assign", _wrap_VectorString_assign, METH_VARARGS, "\n"
		"assign(self, n, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: std::vector< std::string >::size_type\n"
		"x: std::vector< std::string >::value_type const &\n"
		"\n"
		""},
	 { "VectorString_resize", _wrap_VectorString_resize, METH_VARARGS, "\n"
		"resize(self, new_size)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"new_size: std::vector< std::string >::size_type\n"
		"\n"
		"resize(self, new_size, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"new_size: std::vector< std::string >::size_type\n"
		"x: std::vector< std::string >::value_type const &\n"
		"\n"
		""},
	 { "VectorString_insert", _wrap_VectorString_insert, METH_VARARGS, "\n"
		"insert(self, pos, x) -> std::vector< std::string >::iterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pos: std::vector< std::string >::iterator\n"
		"x: std::vector< std::string >::value_type const &\n"
		"\n"
		"insert(self, pos, n, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pos: std::vector< std::string >::iterator\n"
		"n: std::vector< std::string >::size_type\n"
		"x: std::vector< std::string >::value_type const &\n"
		"\n"
		""},
	 { "VectorString_reserve", _wrap_VectorString_reserve, METH_VARARGS, "\n"
		"reserve(self, n)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n: std::vector< std::string >::size_type\n"
		"\n"
		""},
	 { "VectorString_capacity", _wrap_VectorString_capacity, METH_O, "capacity(self) -> std::vector< std::string >::size_type"},
	 { "delete_VectorString", _wrap_delete_VectorString, METH_O, "delete_VectorString(self)"},
	 { "VectorString_swigregister", VectorString_swigregister, METH_O, NULL},
	 { "VectorString_swiginit", VectorString_swiginit, METH_VARARGS, NULL},
	 { "new_IntArray", _wrap_new_IntArray, METH_O, "\n"
		"new_IntArray(nelements) -> IntArray\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nelements: size_t\n"
		"\n"
		""},
	 { "delete_IntArray", _wrap_delete_IntArray, METH_O, "delete_IntArray(self)"},
	 { "IntArray___getitem__", _wrap_IntArray___getitem__, METH_VARARGS, "\n"
		"__getitem__(self, index) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"index: size_t\n"
		"\n"
		""},
	 { "IntArray___setitem__", _wrap_IntArray___setitem__, METH_VARARGS, "\n"
		"__setitem__(self, index, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"index: size_t\n"
		"value: int\n"
		"\n"
		""},
	 { "IntArray_cast", _wrap_IntArray_cast, METH_O, "cast(self) -> int *"},
	 { "IntArray_frompointer", _wrap_IntArray_frompointer, METH_O, "\n"
		"frompointer(t) -> IntArray\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"t: int *\n"
		"\n"
		""},
	 { "IntArray_swigregister", IntArray_swigregister, METH_O, NULL},
	 { "IntArray_swiginit", IntArray_swiginit, METH_VARARGS, NULL},
	 { "SessionIDSet_iterator", _wrap_SessionIDSet_iterator, METH_O, "iterator(self) -> SwigPyIterator"},
	 { "SessionIDSet___nonzero__", _wrap_SessionIDSet___nonzero__, METH_O, "__nonzero__(self) -> bool"},
	 { "SessionIDSet___bool__", _wrap_SessionIDSet___bool__, METH_O, "__bool__(self) -> bool"},
	 { "SessionIDSet___len__", _wrap_SessionIDSet___len__, METH_O, "__len__(self) -> std::set< FIX::SessionID >::size_type"},
	 { "SessionIDSet_append", _wrap_SessionIDSet_append, METH_VARARGS, "\n"
		"append(self, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::value_type\n"
		"\n"
		""},
	 { "SessionIDSet___contains__", _wrap_SessionIDSet___contains__, METH_VARARGS, "\n"
		"__contains__(self, x) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::value_type\n"
		"\n"
		""},
	 { "SessionIDSet___getitem__", _wrap_SessionIDSet___getitem__, METH_VARARGS, "\n"
		"__getitem__(self, i) -> SessionID\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i: std::set< FIX::SessionID >::difference_type\n"
		"\n"
		""},
	 { "SessionIDSet_add", _wrap_SessionIDSet_add, METH_VARARGS, "\n"
		"add(self, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::value_type\n"
		"\n"
		""},
	 { "SessionIDSet_discard", _wrap_SessionIDSet_discard, METH_VARARGS, "\n"
		"discard(self, x)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::value_type\n"
		"\n"
		""},
	 { "new_SessionIDSet", _wrap_new_SessionIDSet, METH_VARARGS, "\n"
		"SessionIDSet(other)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"other: std::less< FIX::SessionID > const &\n"
		"\n"
		"SessionIDSet()\n"
		"new_SessionIDSet(other) -> SessionIDSet\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"other: std::set< FIX::SessionID > const &\n"
		"\n"
		""},
	 { "SessionIDSet_empty", _wrap_SessionIDSet_empty, METH_O, "empty(self) -> bool"},
	 { "SessionIDSet_size", _wrap_SessionIDSet_size, METH_O, "size(self) -> std::set< FIX::SessionID >::size_type"},
	 { "SessionIDSet_clear", _wrap_SessionIDSet_clear, METH_O, "clear(self)"},
	 { "SessionIDSet_swap", _wrap_SessionIDSet_swap, METH_VARARGS, "\n"
		"swap(self, v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v: std::set< FIX::SessionID > &\n"
		"\n"
		""},
	 { "SessionIDSet_count", _wrap_SessionIDSet_count, METH_VARARGS, "\n"
		"count(self, x) -> std::set< FIX::SessionID >::size_type\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::key_type const &\n"
		"\n"
		""},
	 { "SessionIDSet_begin", _wrap_SessionIDSet_begin, METH_O, "begin(self) -> std::set< FIX::SessionID >::iterator"},
	 { "SessionIDSet_end", _wrap_SessionIDSet_end, METH_O, "end(self) -> std::set< FIX::SessionID >::iterator"},
	 { "SessionIDSet_rbegin", _wrap_SessionIDSet_rbegin, METH_O, "rbegin(self) -> std::set< FIX::SessionID >::reverse_iterator"},
	 { "SessionIDSet_rend", _wrap_SessionIDSet_rend, METH_O, "rend(self) -> std::set< FIX::SessionID >::reverse_iterator"},
	 { "SessionIDSet_erase", _wrap_SessionIDSet_erase, METH_VARARGS, "\n"
		"erase(self, x) -> std::set< FIX::SessionID >::size_type\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::key_type const &\n"
		"\n"
		"erase(self, pos)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pos: std::set< FIX::SessionID >::iterator\n"
		"\n"
		"erase(self, first, last)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"first: std::set< FIX::SessionID >::iterator\n"
		"last: std::set< FIX::SessionID >::iterator\n"
		"\n"
		""},
	 { "SessionIDSet_find", _wrap_SessionIDSet_find, METH_VARARGS, "\n"
		"find(self, x) -> std::set< FIX::SessionID >::iterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::key_type const &\n"
		"\n"
		""},
	 { "SessionIDSet_lower_bound", _wrap_SessionIDSet_lower_bound, METH_VARARGS, "\n"
		"lower_bound(self, x) -> std::set< FIX::SessionID >::iterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::key_type const &\n"
		"\n"
		""},
	 { "SessionIDSet_upper_bound", _wrap_SessionIDSet_upper_bound, METH_VARARGS, "\n"
		"upper_bound(self, x) -> std::set< FIX::SessionID >::iterator\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::key_type const &\n"
		"\n"
		""},
	 { "SessionIDSet_equal_range", _wrap_SessionIDSet_equal_range, METH_VARARGS, "\n"
		"equal_range(self, x) -> std::pair< std::set< FIX::SessionID >::iterator,std::set< FIX::SessionID >::iterator >\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"x: std::set< FIX::SessionID >::key_type const &\n"
		"\n"
		""},
	 { "SessionIDSet_insert", _wrap_SessionIDSet_insert, METH_VARARGS, "\n"
		"insert(self, __x) -> std::pair< std::set< FIX::SessionID >::iterator,bool >\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"__x: std::set< FIX::SessionID >::value_type const &\n"
		"\n"
		""},
	 { "delete_SessionIDSet", _wrap_delete_SessionIDSet, METH_O, "delete_SessionIDSet(self)"},
	 { "SessionIDSet_swigregister", SessionIDSet_swigregister, METH_O, NULL},
	 { "SessionIDSet_swiginit", SessionIDSet_swiginit, METH_VARARGS, NULL},
	 { "new_FIXException", _wrap_new_FIXException, METH_VARARGS, "\n"
		"new_FIXException(type, detail) -> FIXException\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type: std::string const &\n"
		"detail: std::string const &\n"
		"\n"
		""},
	 { "delete_FIXException", _wrap_delete_FIXException, METH_O, "delete_FIXException(self)"},
	 { "FIXException_type_set", _wrap_FIXException_type_set, METH_VARARGS, "\n"
		"FIXException_type_set(self, type)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type: std::string const &\n"
		"\n"
		""},
	 { "FIXException_type_get", _wrap_FIXException_type_get, METH_O, "FIXException_type_get(self) -> std::string const &"},
	 { "FIXException_detail_set", _wrap_FIXException_detail_set, METH_VARARGS, "\n"
		"FIXException_detail_set(self, detail)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"detail: std::string const &\n"
		"\n"
		""},
	 { "FIXException_detail_get", _wrap_FIXException_detail_get, METH_O, "FIXException_detail_get(self) -> std::string const &"},
	 { "FIXException___str__", _wrap_FIXException___str__, METH_O, "__str__(self) -> std::string"},
	 { "FIXException_swigregister", FIXException_swigregister, METH_O, NULL},
	 { "FIXException_swiginit", FIXException_swiginit, METH_VARARGS, NULL},
	 { "new_DataDictionaryNotFound", _wrap_new_DataDictionaryNotFound, METH_VARARGS, "\n"
		"DataDictionaryNotFound(version, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"version: std::string const &\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_DataDictionaryNotFound", _wrap_delete_DataDictionaryNotFound, METH_O, "delete_DataDictionaryNotFound(self)"},
	 { "DataDictionaryNotFound_version_set", _wrap_DataDictionaryNotFound_version_set, METH_VARARGS, "\n"
		"DataDictionaryNotFound_version_set(self, version)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"version: std::string const &\n"
		"\n"
		""},
	 { "DataDictionaryNotFound_version_get", _wrap_DataDictionaryNotFound_version_get, METH_O, "DataDictionaryNotFound_version_get(self) -> std::string const &"},
	 { "DataDictionaryNotFound_swigregister", DataDictionaryNotFound_swigregister, METH_O, NULL},
	 { "DataDictionaryNotFound_swiginit", DataDictionaryNotFound_swiginit, METH_VARARGS, NULL},
	 { "new_FieldNotFound", _wrap_new_FieldNotFound, METH_VARARGS, "\n"
		"FieldNotFound(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "FieldNotFound_field_set", _wrap_FieldNotFound_field_set, METH_VARARGS, "\n"
		"FieldNotFound_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "FieldNotFound_field_get", _wrap_FieldNotFound_field_get, METH_O, "FieldNotFound_field_get(self) -> int"},
	 { "delete_FieldNotFound", _wrap_delete_FieldNotFound, METH_O, "delete_FieldNotFound(self)"},
	 { "FieldNotFound_swigregister", FieldNotFound_swigregister, METH_O, NULL},
	 { "FieldNotFound_swiginit", FieldNotFound_swiginit, METH_VARARGS, NULL},
	 { "new_FieldConvertError", _wrap_new_FieldConvertError, METH_VARARGS, "\n"
		"FieldConvertError(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_FieldConvertError", _wrap_delete_FieldConvertError, METH_O, "delete_FieldConvertError(self)"},
	 { "FieldConvertError_swigregister", FieldConvertError_swigregister, METH_O, NULL},
	 { "FieldConvertError_swiginit", FieldConvertError_swiginit, METH_VARARGS, NULL},
	 { "new_MessageParseError", _wrap_new_MessageParseError, METH_VARARGS, "\n"
		"MessageParseError(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_MessageParseError", _wrap_delete_MessageParseError, METH_O, "delete_MessageParseError(self)"},
	 { "MessageParseError_swigregister", MessageParseError_swigregister, METH_O, NULL},
	 { "MessageParseError_swiginit", MessageParseError_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidMessage", _wrap_new_InvalidMessage, METH_VARARGS, "\n"
		"InvalidMessage(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_InvalidMessage", _wrap_delete_InvalidMessage, METH_O, "delete_InvalidMessage(self)"},
	 { "InvalidMessage_swigregister", InvalidMessage_swigregister, METH_O, NULL},
	 { "InvalidMessage_swiginit", InvalidMessage_swiginit, METH_VARARGS, NULL},
	 { "new_ConfigError", _wrap_new_ConfigError, METH_VARARGS, "\n"
		"ConfigError(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_ConfigError", _wrap_delete_ConfigError, METH_O, "delete_ConfigError(self)"},
	 { "ConfigError_swigregister", ConfigError_swigregister, METH_O, NULL},
	 { "ConfigError_swiginit", ConfigError_swiginit, METH_VARARGS, NULL},
	 { "new_RuntimeError", _wrap_new_RuntimeError, METH_VARARGS, "\n"
		"RuntimeError(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_RuntimeError", _wrap_delete_RuntimeError, METH_O, "delete_RuntimeError(self)"},
	 { "RuntimeError_swigregister", RuntimeError_swigregister, METH_O, NULL},
	 { "RuntimeError_swiginit", RuntimeError_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidTagNumber", _wrap_new_InvalidTagNumber, METH_VARARGS, "\n"
		"InvalidTagNumber(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "InvalidTagNumber_field_set", _wrap_InvalidTagNumber_field_set, METH_VARARGS, "\n"
		"InvalidTagNumber_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "InvalidTagNumber_field_get", _wrap_InvalidTagNumber_field_get, METH_O, "InvalidTagNumber_field_get(self) -> int"},
	 { "delete_InvalidTagNumber", _wrap_delete_InvalidTagNumber, METH_O, "delete_InvalidTagNumber(self)"},
	 { "InvalidTagNumber_swigregister", InvalidTagNumber_swigregister, METH_O, NULL},
	 { "InvalidTagNumber_swiginit", InvalidTagNumber_swiginit, METH_VARARGS, NULL},
	 { "new_RequiredTagMissing", _wrap_new_RequiredTagMissing, METH_VARARGS, "\n"
		"RequiredTagMissing(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "RequiredTagMissing_field_set", _wrap_RequiredTagMissing_field_set, METH_VARARGS, "\n"
		"RequiredTagMissing_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "RequiredTagMissing_field_get", _wrap_RequiredTagMissing_field_get, METH_O, "RequiredTagMissing_field_get(self) -> int"},
	 { "delete_RequiredTagMissing", _wrap_delete_RequiredTagMissing, METH_O, "delete_RequiredTagMissing(self)"},
	 { "RequiredTagMissing_swigregister", RequiredTagMissing_swigregister, METH_O, NULL},
	 { "RequiredTagMissing_swiginit", RequiredTagMissing_swiginit, METH_VARARGS, NULL},
	 { "new_TagNotDefinedForMessage", _wrap_new_TagNotDefinedForMessage, METH_VARARGS, "\n"
		"TagNotDefinedForMessage(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "TagNotDefinedForMessage_field_set", _wrap_TagNotDefinedForMessage_field_set, METH_VARARGS, "\n"
		"TagNotDefinedForMessage_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "TagNotDefinedForMessage_field_get", _wrap_TagNotDefinedForMessage_field_get, METH_O, "TagNotDefinedForMessage_field_get(self) -> int"},
	 { "delete_TagNotDefinedForMessage", _wrap_delete_TagNotDefinedForMessage, METH_O, "delete_TagNotDefinedForMessage(self)"},
	 { "TagNotDefinedForMessage_swigregister", TagNotDefinedForMessage_swigregister, METH_O, NULL},
	 { "TagNotDefinedForMessage_swiginit", TagNotDefinedForMessage_swiginit, METH_VARARGS, NULL},
	 { "new_NoTagValue", _wrap_new_NoTagValue, METH_VARARGS, "\n"
		"NoTagValue(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "NoTagValue_field_set", _wrap_NoTagValue_field_set, METH_VARARGS, "\n"
		"NoTagValue_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "NoTagValue_field_get", _wrap_NoTagValue_field_get, METH_O, "NoTagValue_field_get(self) -> int"},
	 { "delete_NoTagValue", _wrap_delete_NoTagValue, METH_O, "delete_NoTagValue(self)"},
	 { "NoTagValue_swigregister", NoTagValue_swigregister, METH_O, NULL},
	 { "NoTagValue_swiginit", NoTagValue_swiginit, METH_VARARGS, NULL},
	 { "new_IncorrectTagValue", _wrap_new_IncorrectTagValue, METH_VARARGS, "\n"
		"IncorrectTagValue(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "IncorrectTagValue_field_set", _wrap_IncorrectTagValue_field_set, METH_VARARGS, "\n"
		"IncorrectTagValue_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "IncorrectTagValue_field_get", _wrap_IncorrectTagValue_field_get, METH_O, "IncorrectTagValue_field_get(self) -> int"},
	 { "delete_IncorrectTagValue", _wrap_delete_IncorrectTagValue, METH_O, "delete_IncorrectTagValue(self)"},
	 { "IncorrectTagValue_swigregister", IncorrectTagValue_swigregister, METH_O, NULL},
	 { "IncorrectTagValue_swiginit", IncorrectTagValue_swiginit, METH_VARARGS, NULL},
	 { "new_IncorrectDataFormat", _wrap_new_IncorrectDataFormat, METH_VARARGS, "\n"
		"IncorrectDataFormat(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "IncorrectDataFormat_field_set", _wrap_IncorrectDataFormat_field_set, METH_VARARGS, "\n"
		"IncorrectDataFormat_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "IncorrectDataFormat_field_get", _wrap_IncorrectDataFormat_field_get, METH_O, "IncorrectDataFormat_field_get(self) -> int"},
	 { "delete_IncorrectDataFormat", _wrap_delete_IncorrectDataFormat, METH_O, "delete_IncorrectDataFormat(self)"},
	 { "IncorrectDataFormat_swigregister", IncorrectDataFormat_swigregister, METH_O, NULL},
	 { "IncorrectDataFormat_swiginit", IncorrectDataFormat_swiginit, METH_VARARGS, NULL},
	 { "new_IncorrectMessageStructure", _wrap_new_IncorrectMessageStructure, METH_VARARGS, "\n"
		"IncorrectMessageStructure(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_IncorrectMessageStructure", _wrap_delete_IncorrectMessageStructure, METH_O, "delete_IncorrectMessageStructure(self)"},
	 { "IncorrectMessageStructure_swigregister", IncorrectMessageStructure_swigregister, METH_O, NULL},
	 { "IncorrectMessageStructure_swiginit", IncorrectMessageStructure_swiginit, METH_VARARGS, NULL},
	 { "new_DuplicateFieldNumber", _wrap_new_DuplicateFieldNumber, METH_VARARGS, "\n"
		"DuplicateFieldNumber(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_DuplicateFieldNumber", _wrap_delete_DuplicateFieldNumber, METH_O, "delete_DuplicateFieldNumber(self)"},
	 { "DuplicateFieldNumber_swigregister", DuplicateFieldNumber_swigregister, METH_O, NULL},
	 { "DuplicateFieldNumber_swiginit", DuplicateFieldNumber_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidMessageType", _wrap_new_InvalidMessageType, METH_VARARGS, "\n"
		"InvalidMessageType(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_InvalidMessageType", _wrap_delete_InvalidMessageType, METH_O, "delete_InvalidMessageType(self)"},
	 { "InvalidMessageType_swigregister", InvalidMessageType_swigregister, METH_O, NULL},
	 { "InvalidMessageType_swiginit", InvalidMessageType_swiginit, METH_VARARGS, NULL},
	 { "new_UnsupportedMessageType", _wrap_new_UnsupportedMessageType, METH_VARARGS, "\n"
		"UnsupportedMessageType(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_UnsupportedMessageType", _wrap_delete_UnsupportedMessageType, METH_O, "delete_UnsupportedMessageType(self)"},
	 { "UnsupportedMessageType_swigregister", UnsupportedMessageType_swigregister, METH_O, NULL},
	 { "UnsupportedMessageType_swiginit", UnsupportedMessageType_swiginit, METH_VARARGS, NULL},
	 { "new_UnsupportedVersion", _wrap_new_UnsupportedVersion, METH_VARARGS, "\n"
		"UnsupportedVersion(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_UnsupportedVersion", _wrap_delete_UnsupportedVersion, METH_O, "delete_UnsupportedVersion(self)"},
	 { "UnsupportedVersion_swigregister", UnsupportedVersion_swigregister, METH_O, NULL},
	 { "UnsupportedVersion_swiginit", UnsupportedVersion_swiginit, METH_VARARGS, NULL},
	 { "new_TagOutOfOrder", _wrap_new_TagOutOfOrder, METH_VARARGS, "\n"
		"TagOutOfOrder(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "TagOutOfOrder_field_set", _wrap_TagOutOfOrder_field_set, METH_VARARGS, "\n"
		"TagOutOfOrder_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "TagOutOfOrder_field_get", _wrap_TagOutOfOrder_field_get, METH_O, "TagOutOfOrder_field_get(self) -> int"},
	 { "delete_TagOutOfOrder", _wrap_delete_TagOutOfOrder, METH_O, "delete_TagOutOfOrder(self)"},
	 { "TagOutOfOrder_swigregister", TagOutOfOrder_swigregister, METH_O, NULL},
	 { "TagOutOfOrder_swiginit", TagOutOfOrder_swiginit, METH_VARARGS, NULL},
	 { "new_RepeatedTag", _wrap_new_RepeatedTag, METH_VARARGS, "\n"
		"RepeatedTag(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "RepeatedTag_field_set", _wrap_RepeatedTag_field_set, METH_VARARGS, "\n"
		"RepeatedTag_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "RepeatedTag_field_get", _wrap_RepeatedTag_field_get, METH_O, "RepeatedTag_field_get(self) -> int"},
	 { "delete_RepeatedTag", _wrap_delete_RepeatedTag, METH_O, "delete_RepeatedTag(self)"},
	 { "RepeatedTag_swigregister", RepeatedTag_swigregister, METH_O, NULL},
	 { "RepeatedTag_swiginit", RepeatedTag_swiginit, METH_VARARGS, NULL},
	 { "new_RepeatingGroupCountMismatch", _wrap_new_RepeatingGroupCountMismatch, METH_VARARGS, "\n"
		"RepeatingGroupCountMismatch(field=0, what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "RepeatingGroupCountMismatch_field_set", _wrap_RepeatingGroupCountMismatch_field_set, METH_VARARGS, "\n"
		"RepeatingGroupCountMismatch_field_set(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "RepeatingGroupCountMismatch_field_get", _wrap_RepeatingGroupCountMismatch_field_get, METH_O, "RepeatingGroupCountMismatch_field_get(self) -> int"},
	 { "delete_RepeatingGroupCountMismatch", _wrap_delete_RepeatingGroupCountMismatch, METH_O, "delete_RepeatingGroupCountMismatch(self)"},
	 { "RepeatingGroupCountMismatch_swigregister", RepeatingGroupCountMismatch_swigregister, METH_O, NULL},
	 { "RepeatingGroupCountMismatch_swiginit", RepeatingGroupCountMismatch_swiginit, METH_VARARGS, NULL},
	 { "new_DoNotSend", _wrap_new_DoNotSend, METH_VARARGS, "\n"
		"DoNotSend(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_DoNotSend", _wrap_delete_DoNotSend, METH_O, "delete_DoNotSend(self)"},
	 { "DoNotSend_swigregister", DoNotSend_swigregister, METH_O, NULL},
	 { "DoNotSend_swiginit", DoNotSend_swiginit, METH_VARARGS, NULL},
	 { "new_RejectLogon", _wrap_new_RejectLogon, METH_VARARGS, "\n"
		"RejectLogon(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_RejectLogon", _wrap_delete_RejectLogon, METH_O, "delete_RejectLogon(self)"},
	 { "RejectLogon_swigregister", RejectLogon_swigregister, METH_O, NULL},
	 { "RejectLogon_swiginit", RejectLogon_swiginit, METH_VARARGS, NULL},
	 { "new_SessionNotFound", _wrap_new_SessionNotFound, METH_VARARGS, "\n"
		"SessionNotFound(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_SessionNotFound", _wrap_delete_SessionNotFound, METH_O, "delete_SessionNotFound(self)"},
	 { "SessionNotFound_swigregister", SessionNotFound_swigregister, METH_O, NULL},
	 { "SessionNotFound_swiginit", SessionNotFound_swiginit, METH_VARARGS, NULL},
	 { "new_IOException", _wrap_new_IOException, METH_VARARGS, "\n"
		"IOException(what=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_IOException", _wrap_delete_IOException, METH_O, "delete_IOException(self)"},
	 { "IOException_swigregister", IOException_swigregister, METH_O, NULL},
	 { "IOException_swiginit", IOException_swiginit, METH_VARARGS, NULL},
	 { "new_SocketException", _wrap_new_SocketException, METH_VARARGS, "\n"
		"SocketException()\n"
		"new_SocketException(what) -> SocketException\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "SocketException_errorToWhat", _wrap_SocketException_errorToWhat, METH_NOARGS, "errorToWhat() -> std::string"},
	 { "delete_SocketException", _wrap_delete_SocketException, METH_O, "delete_SocketException(self)"},
	 { "SocketException_swigregister", SocketException_swigregister, METH_O, NULL},
	 { "SocketException_swiginit", SocketException_swiginit, METH_VARARGS, NULL},
	 { "new_SocketSendFailed", _wrap_new_SocketSendFailed, METH_VARARGS, "\n"
		"SocketSendFailed()\n"
		"new_SocketSendFailed(what) -> SocketSendFailed\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_SocketSendFailed", _wrap_delete_SocketSendFailed, METH_O, "delete_SocketSendFailed(self)"},
	 { "SocketSendFailed_swigregister", SocketSendFailed_swigregister, METH_O, NULL},
	 { "SocketSendFailed_swiginit", SocketSendFailed_swiginit, METH_VARARGS, NULL},
	 { "new_SocketRecvFailed", _wrap_new_SocketRecvFailed, METH_VARARGS, "\n"
		"SocketRecvFailed(size)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"size: ssize_t\n"
		"\n"
		"new_SocketRecvFailed(what) -> SocketRecvFailed\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_SocketRecvFailed", _wrap_delete_SocketRecvFailed, METH_O, "delete_SocketRecvFailed(self)"},
	 { "SocketRecvFailed_swigregister", SocketRecvFailed_swigregister, METH_O, NULL},
	 { "SocketRecvFailed_swiginit", SocketRecvFailed_swiginit, METH_VARARGS, NULL},
	 { "new_SocketCloseFailed", _wrap_new_SocketCloseFailed, METH_VARARGS, "\n"
		"SocketCloseFailed()\n"
		"new_SocketCloseFailed(what) -> SocketCloseFailed\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"what: std::string const &\n"
		"\n"
		""},
	 { "delete_SocketCloseFailed", _wrap_delete_SocketCloseFailed, METH_O, "delete_SocketCloseFailed(self)"},
	 { "SocketCloseFailed_swigregister", SocketCloseFailed_swigregister, METH_O, NULL},
	 { "SocketCloseFailed_swiginit", SocketCloseFailed_swiginit, METH_VARARGS, NULL},
	 { "DateTime_m_date_set", _wrap_DateTime_m_date_set, METH_VARARGS, "\n"
		"DateTime_m_date_set(self, m_date)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"m_date: int\n"
		"\n"
		""},
	 { "DateTime_m_date_get", _wrap_DateTime_m_date_get, METH_O, "DateTime_m_date_get(self) -> int"},
	 { "DateTime_m_time_set", _wrap_DateTime_m_time_set, METH_VARARGS, "\n"
		"DateTime_m_time_set(self, m_time)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"m_time: int64_t\n"
		"\n"
		""},
	 { "DateTime_m_time_get", _wrap_DateTime_m_time_get, METH_O, "DateTime_m_time_get(self) -> int64_t"},
	 { "new_DateTime", _wrap_new_DateTime, METH_VARARGS, "\n"
		"DateTime()\n"
		"DateTime(date, time)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"date: int\n"
		"time: int64_t\n"
		"\n"
		"DateTime(year, month, day, hour, minute, second, millis)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"year: int\n"
		"month: int\n"
		"day: int\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millis: int\n"
		"\n"
		"new_DateTime(year, month, day, hour, minute, second, fraction, precision) -> DateTime\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"year: int\n"
		"month: int\n"
		"day: int\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "delete_DateTime", _wrap_delete_DateTime, METH_O, "delete_DateTime(self)"},
	 { "DateTime_getYear", _wrap_DateTime_getYear, METH_O, "getYear(self) -> int"},
	 { "DateTime_getMonth", _wrap_DateTime_getMonth, METH_O, "getMonth(self) -> int"},
	 { "DateTime_getDay", _wrap_DateTime_getDay, METH_O, "getDay(self) -> int"},
	 { "DateTime_getDate", _wrap_DateTime_getDate, METH_O, "getDate(self) -> int"},
	 { "DateTime_getJulianDate", _wrap_DateTime_getJulianDate, METH_O, "getJulianDate(self) -> int"},
	 { "DateTime_getHour", _wrap_DateTime_getHour, METH_O, "getHour(self) -> int"},
	 { "DateTime_getMinute", _wrap_DateTime_getMinute, METH_O, "getMinute(self) -> int"},
	 { "DateTime_getSecond", _wrap_DateTime_getSecond, METH_O, "getSecond(self) -> int"},
	 { "DateTime_getMillisecond", _wrap_DateTime_getMillisecond, METH_O, "getMillisecond(self) -> int"},
	 { "DateTime_getMicrosecond", _wrap_DateTime_getMicrosecond, METH_O, "getMicrosecond(self) -> int"},
	 { "DateTime_getNanosecond", _wrap_DateTime_getNanosecond, METH_O, "getNanosecond(self) -> unsigned int"},
	 { "DateTime_getFraction", _wrap_DateTime_getFraction, METH_VARARGS, "\n"
		"getFraction(self, precision) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"precision: int\n"
		"\n"
		""},
	 { "DateTime_getWeekDay", _wrap_DateTime_getWeekDay, METH_O, "getWeekDay(self) -> int"},
	 { "DateTime_getTimeT", _wrap_DateTime_getTimeT, METH_O, "getTimeT(self) -> time_t"},
	 { "DateTime_getTmUtc", _wrap_DateTime_getTmUtc, METH_O, "getTmUtc(self) -> tm"},
	 { "DateTime_setYMD", _wrap_DateTime_setYMD, METH_VARARGS, "\n"
		"setYMD(self, year, month, day)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"year: int\n"
		"month: int\n"
		"day: int\n"
		"\n"
		""},
	 { "DateTime_setHMS", _wrap_DateTime_setHMS, METH_VARARGS, "\n"
		"setHMS(self, hour, minute, second, millis)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millis: int\n"
		"\n"
		"setHMS(self, hour, minute, second, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "DateTime_setHour", _wrap_DateTime_setHour, METH_VARARGS, "\n"
		"setHour(self, hour)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"\n"
		""},
	 { "DateTime_setMinute", _wrap_DateTime_setMinute, METH_VARARGS, "\n"
		"setMinute(self, min)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"min: int\n"
		"\n"
		""},
	 { "DateTime_setSecond", _wrap_DateTime_setSecond, METH_VARARGS, "\n"
		"setSecond(self, sec)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sec: int\n"
		"\n"
		""},
	 { "DateTime_setMillisecond", _wrap_DateTime_setMillisecond, METH_VARARGS, "\n"
		"setMillisecond(self, millis)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"millis: int\n"
		"\n"
		""},
	 { "DateTime_setMicrosecond", _wrap_DateTime_setMicrosecond, METH_VARARGS, "\n"
		"setMicrosecond(self, micros)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"micros: int\n"
		"\n"
		""},
	 { "DateTime_setNanosecond", _wrap_DateTime_setNanosecond, METH_VARARGS, "\n"
		"setNanosecond(self, nanos)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nanos: int\n"
		"\n"
		""},
	 { "DateTime_setFraction", _wrap_DateTime_setFraction, METH_VARARGS, "\n"
		"setFraction(self, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "DateTime_clearDate", _wrap_DateTime_clearDate, METH_O, "clearDate(self)"},
	 { "DateTime_clearTime", _wrap_DateTime_clearTime, METH_O, "clearTime(self)"},
	 { "DateTime_set", _wrap_DateTime_set, METH_VARARGS, "\n"
		"set(self, date, time)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"date: int\n"
		"time: int64_t\n"
		"\n"
		"set(self, other)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"other: FIX::DateTime const &\n"
		"\n"
		""},
	 { "DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, "\n"
		"__iadd__(self, seconds)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"seconds: int\n"
		"\n"
		""},
	 { "DateTime_convertToNanos", _wrap_DateTime_convertToNanos, METH_VARARGS, "\n"
		"convertToNanos(fraction, precision) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "DateTime_makeHMS", _wrap_DateTime_makeHMS, METH_VARARGS, "\n"
		"makeHMS(hour, minute, second, nanos) -> int64_t\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"nanos: int\n"
		"\n"
		""},
	 { "DateTime_nowUtc", _wrap_DateTime_nowUtc, METH_NOARGS, "nowUtc() -> DateTime"},
	 { "DateTime_nowLocal", _wrap_DateTime_nowLocal, METH_NOARGS, "nowLocal() -> DateTime"},
	 { "DateTime_fromUtcTimeT", _wrap_DateTime_fromUtcTimeT, METH_VARARGS, "\n"
		"fromUtcTimeT(t, millis=0) -> DateTime\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"t: time_t\n"
		"millis: int\n"
		"\n"
		"fromUtcTimeT(t, fraction, precision) -> DateTime\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"t: time_t\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "DateTime_fromLocalTimeT", _wrap_DateTime_fromLocalTimeT, METH_VARARGS, "\n"
		"fromLocalTimeT(t, millis=0) -> DateTime\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"t: time_t\n"
		"millis: int\n"
		"\n"
		"fromLocalTimeT(t, fraction, precision) -> DateTime\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"t: time_t\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "DateTime_fromTm", _wrap_DateTime_fromTm, METH_VARARGS, "\n"
		"fromTm(tm, millis=0) -> DateTime\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tm: tm const &\n"
		"millis: int\n"
		"\n"
		"fromTm(tm, fraction, precision) -> DateTime\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tm: tm const &\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "DateTime_julianDate", _wrap_DateTime_julianDate, METH_VARARGS, "\n"
		"julianDate(year, month, day) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"year: int\n"
		"month: int\n"
		"day: int\n"
		"\n"
		""},
	 { "DateTime_swigregister", DateTime_swigregister, METH_O, NULL},
	 { "DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
	 { "__sub__", _wrap___sub__, METH_VARARGS, "\n"
		"__sub__(lhs, rhs) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::DateTime const &\n"
		"rhs: FIX::DateTime const &\n"
		"\n"
		""},
	 { "UtcTimeStamp_now", _wrap_UtcTimeStamp_now, METH_NOARGS, "now() -> UtcTimeStamp"},
	 { "new_UtcTimeStamp", _wrap_new_UtcTimeStamp, METH_VARARGS, "\n"
		"UtcTimeStamp()\n"
		"UtcTimeStamp(dateTime)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dateTime: FIX::DateTime\n"
		"\n"
		"UtcTimeStamp(hour, minute, second, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millisecond: int\n"
		"\n"
		"UtcTimeStamp(hour, minute, second, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"UtcTimeStamp(hour, minute, second, date, month, year)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"\n"
		"UtcTimeStamp(hour, minute, second, millisecond, date, month, year)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millisecond: int\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"\n"
		"UtcTimeStamp(hour, minute, second, fraction, date, month, year, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"precision: int\n"
		"\n"
		"UtcTimeStamp(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"millisecond: int\n"
		"\n"
		"UtcTimeStamp(time, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"UtcTimeStamp(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"millisecond: int\n"
		"\n"
		"new_UtcTimeStamp(time, fraction, precision) -> UtcTimeStamp\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "UtcTimeStamp_setCurrent", _wrap_UtcTimeStamp_setCurrent, METH_O, "setCurrent(self)"},
	 { "UtcTimeStamp_getDateTime", _wrap_UtcTimeStamp_getDateTime, METH_O, "getDateTime(self) -> PyObject *"},
	 { "delete_UtcTimeStamp", _wrap_delete_UtcTimeStamp, METH_O, "delete_UtcTimeStamp(self)"},
	 { "UtcTimeStamp_swigregister", UtcTimeStamp_swigregister, METH_O, NULL},
	 { "UtcTimeStamp_swiginit", UtcTimeStamp_swiginit, METH_VARARGS, NULL},
	 { "new_LocalTimeStamp", _wrap_new_LocalTimeStamp, METH_VARARGS, "\n"
		"LocalTimeStamp()\n"
		"LocalTimeStamp(hour, minute, second, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millisecond: int\n"
		"\n"
		"LocalTimeStamp(hour, minute, second, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"LocalTimeStamp(hour, minute, second, date, month, year)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"\n"
		"LocalTimeStamp(hour, minute, second, millisecond, date, month, year)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millisecond: int\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"\n"
		"LocalTimeStamp(hour, minute, second, fraction, date, month, year, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"precision: int\n"
		"\n"
		"LocalTimeStamp(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"millisecond: int\n"
		"\n"
		"LocalTimeStamp(time, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"LocalTimeStamp(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"millisecond: int\n"
		"\n"
		"new_LocalTimeStamp(time, fraction, precision) -> LocalTimeStamp\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "LocalTimeStamp_setCurrent", _wrap_LocalTimeStamp_setCurrent, METH_O, "setCurrent(self)"},
	 { "delete_LocalTimeStamp", _wrap_delete_LocalTimeStamp, METH_O, "delete_LocalTimeStamp(self)"},
	 { "LocalTimeStamp_swigregister", LocalTimeStamp_swigregister, METH_O, NULL},
	 { "LocalTimeStamp_swiginit", LocalTimeStamp_swiginit, METH_VARARGS, NULL},
	 { "new_UtcTimeOnly", _wrap_new_UtcTimeOnly, METH_VARARGS, "\n"
		"UtcTimeOnly()\n"
		"UtcTimeOnly(val)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"val: FIX::DateTime const &\n"
		"\n"
		"UtcTimeOnly(hour, minute, second, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millisecond: int\n"
		"\n"
		"UtcTimeOnly(hour, minute, second, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"UtcTimeOnly(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"millisecond: int\n"
		"\n"
		"UtcTimeOnly(time, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"UtcTimeOnly(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"millisecond: int\n"
		"\n"
		"new_UtcTimeOnly(time, fraction, precision) -> UtcTimeOnly\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "UtcTimeOnly_setCurrent", _wrap_UtcTimeOnly_setCurrent, METH_O, "setCurrent(self)"},
	 { "delete_UtcTimeOnly", _wrap_delete_UtcTimeOnly, METH_O, "delete_UtcTimeOnly(self)"},
	 { "UtcTimeOnly_swigregister", UtcTimeOnly_swigregister, METH_O, NULL},
	 { "UtcTimeOnly_swiginit", UtcTimeOnly_swiginit, METH_VARARGS, NULL},
	 { "new_LocalTimeOnly", _wrap_new_LocalTimeOnly, METH_VARARGS, "\n"
		"LocalTimeOnly()\n"
		"LocalTimeOnly(val)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"val: FIX::DateTime const &\n"
		"\n"
		"LocalTimeOnly(hour, minute, second, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"millisecond: int\n"
		"\n"
		"LocalTimeOnly(hour, minute, second, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hour: int\n"
		"minute: int\n"
		"second: int\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"LocalTimeOnly(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"millisecond: int\n"
		"\n"
		"LocalTimeOnly(time, fraction, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: time_t\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		"LocalTimeOnly(time, millisecond=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"millisecond: int\n"
		"\n"
		"new_LocalTimeOnly(time, fraction, precision) -> LocalTimeOnly\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"fraction: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "LocalTimeOnly_setCurrent", _wrap_LocalTimeOnly_setCurrent, METH_O, "setCurrent(self)"},
	 { "delete_LocalTimeOnly", _wrap_delete_LocalTimeOnly, METH_O, "delete_LocalTimeOnly(self)"},
	 { "LocalTimeOnly_swigregister", LocalTimeOnly_swigregister, METH_O, NULL},
	 { "LocalTimeOnly_swiginit", LocalTimeOnly_swiginit, METH_VARARGS, NULL},
	 { "new_UtcDate", _wrap_new_UtcDate, METH_VARARGS, "\n"
		"UtcDate()\n"
		"UtcDate(val)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"val: FIX::DateTime const &\n"
		"\n"
		"UtcDate(date, month, year)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"\n"
		"UtcDate(sec)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sec: int\n"
		"\n"
		"new_UtcDate(time) -> UtcDate\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"\n"
		""},
	 { "UtcDate_setCurrent", _wrap_UtcDate_setCurrent, METH_O, "setCurrent(self)"},
	 { "delete_UtcDate", _wrap_delete_UtcDate, METH_O, "delete_UtcDate(self)"},
	 { "UtcDate_swigregister", UtcDate_swigregister, METH_O, NULL},
	 { "UtcDate_swiginit", UtcDate_swiginit, METH_VARARGS, NULL},
	 { "new_LocalDate", _wrap_new_LocalDate, METH_VARARGS, "\n"
		"LocalDate()\n"
		"LocalDate(val)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"val: FIX::DateTime const &\n"
		"\n"
		"LocalDate(date, month, year)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"date: int\n"
		"month: int\n"
		"year: int\n"
		"\n"
		"LocalDate(sec)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sec: int\n"
		"\n"
		"new_LocalDate(time) -> LocalDate\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"time: tm const *\n"
		"\n"
		""},
	 { "LocalDate_setCurrent", _wrap_LocalDate_setCurrent, METH_O, "setCurrent(self)"},
	 { "delete_LocalDate", _wrap_delete_LocalDate, METH_O, "delete_LocalDate(self)"},
	 { "LocalDate_swigregister", LocalDate_swigregister, METH_O, NULL},
	 { "LocalDate_swiginit", LocalDate_swiginit, METH_VARARGS, NULL},
	 { "delete_FieldBase", _wrap_delete_FieldBase, METH_O, "delete_FieldBase(self)"},
	 { "new_FieldBase", _wrap_new_FieldBase, METH_VARARGS, "\n"
		"FieldBase(tag, string)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"string: std::string const &\n"
		"\n"
		"new_FieldBase(rhs) -> FieldBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::FieldBase const &\n"
		"\n"
		""},
	 { "FieldBase_swap", _wrap_FieldBase_swap, METH_VARARGS, "\n"
		"swap(self, rhs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::FieldBase &\n"
		"\n"
		""},
	 { "FieldBase_setTag", _wrap_FieldBase_setTag, METH_VARARGS, "\n"
		"setTag(self, tag)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldBase_setField", _wrap_FieldBase_setField, METH_VARARGS, "\n"
		"setField(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "FieldBase_setString", _wrap_FieldBase_setString, METH_VARARGS, "\n"
		"setString(self, string)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"\n"
		""},
	 { "FieldBase_getTag", _wrap_FieldBase_getTag, METH_O, "getTag(self) -> int"},
	 { "FieldBase_getField", _wrap_FieldBase_getField, METH_O, "getField(self) -> int"},
	 { "FieldBase_getString", _wrap_FieldBase_getString, METH_O, "getString(self) -> std::string const &"},
	 { "FieldBase_getFixString", _wrap_FieldBase_getFixString, METH_O, "getFixString(self) -> std::string const &"},
	 { "FieldBase_getLength", _wrap_FieldBase_getLength, METH_O, "getLength(self) -> int"},
	 { "FieldBase_getTotal", _wrap_FieldBase_getTotal, METH_O, "getTotal(self) -> int"},
	 { "FieldBase___lt__", _wrap_FieldBase___lt__, METH_VARARGS, "\n"
		"__lt__(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: FIX::FieldBase const &\n"
		"\n"
		""},
	 { "FieldBase___str__", _wrap_FieldBase___str__, METH_O, "__str__(self) -> std::string"},
	 { "FieldBase_swigregister", FieldBase_swigregister, METH_O, NULL},
	 { "FieldBase_swiginit", FieldBase_swiginit, METH_VARARGS, NULL},
	 { "swap", _wrap_swap, METH_VARARGS, "\n"
		"swap(lhs, rhs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::FieldBase &\n"
		"rhs: FIX::FieldBase &\n"
		"\n"
		""},
	 { "new_StringField", _wrap_new_StringField, METH_VARARGS, "\n"
		"StringField(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: std::string const &\n"
		"\n"
		"new_StringField(field) -> StringField\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "StringField_setValue", _wrap_StringField_setValue, METH_VARARGS, "\n"
		"setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "StringField_getValue", _wrap_StringField_getValue, METH_O, "getValue(self) -> std::string const &"},
	 { "StringField___lt__", _wrap_StringField___lt__, METH_VARARGS, "\n"
		"__lt__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::StringField const &\n"
		"\n"
		""},
	 { "StringField___gt__", _wrap_StringField___gt__, METH_VARARGS, "\n"
		"__gt__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::StringField const &\n"
		"\n"
		""},
	 { "StringField___eq__", _wrap_StringField___eq__, METH_VARARGS, "\n"
		"__eq__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::StringField const &\n"
		"\n"
		""},
	 { "StringField___ne__", _wrap_StringField___ne__, METH_VARARGS, "\n"
		"__ne__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::StringField const &\n"
		"\n"
		""},
	 { "StringField___le__", _wrap_StringField___le__, METH_VARARGS, "\n"
		"__le__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::StringField const &\n"
		"\n"
		""},
	 { "StringField___ge__", _wrap_StringField___ge__, METH_VARARGS, "\n"
		"__ge__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::StringField const &\n"
		"\n"
		""},
	 { "__gt__", _wrap___gt__, METH_VARARGS, "\n"
		"__gt__(lhs, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::DateTime const &\n"
		"rhs: FIX::DateTime const &\n"
		"\n"
		"__gt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: char const *\n"
		"\n"
		"__gt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: char const *\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__gt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: std::string const &\n"
		"\n"
		"__gt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::string const &\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		""},
	 { "__le__", _wrap___le__, METH_VARARGS, "\n"
		"__le__(lhs, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::DateTime const &\n"
		"rhs: FIX::DateTime const &\n"
		"\n"
		"__le__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: char const *\n"
		"\n"
		"__le__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: char const *\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__le__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: std::string const &\n"
		"\n"
		"__le__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::string const &\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		""},
	 { "__ge__", _wrap___ge__, METH_VARARGS, "\n"
		"__ge__(lhs, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::DateTime const &\n"
		"rhs: FIX::DateTime const &\n"
		"\n"
		"__ge__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: char const *\n"
		"\n"
		"__ge__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: char const *\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__ge__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: std::string const &\n"
		"\n"
		"__ge__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::string const &\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		""},
	 { "delete_StringField", _wrap_delete_StringField, METH_O, "delete_StringField(self)"},
	 { "StringField_swigregister", StringField_swigregister, METH_O, NULL},
	 { "StringField_swiginit", StringField_swiginit, METH_VARARGS, NULL},
	 { "new_CharField", _wrap_new_CharField, METH_VARARGS, "\n"
		"CharField(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: char\n"
		"\n"
		"new_CharField(field) -> CharField\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "CharField_setValue", _wrap_CharField_setValue, METH_VARARGS, "\n"
		"setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: char\n"
		"\n"
		""},
	 { "CharField_getValue", _wrap_CharField_getValue, METH_O, "getValue(self) -> char"},
	 { "delete_CharField", _wrap_delete_CharField, METH_O, "delete_CharField(self)"},
	 { "CharField_swigregister", CharField_swigregister, METH_O, NULL},
	 { "CharField_swiginit", CharField_swiginit, METH_VARARGS, NULL},
	 { "new_DoubleField", _wrap_new_DoubleField, METH_VARARGS, "\n"
		"DoubleField(field, data, padding=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: double\n"
		"padding: int\n"
		"\n"
		"new_DoubleField(field) -> DoubleField\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DoubleField_setValue", _wrap_DoubleField_setValue, METH_VARARGS, "\n"
		"setValue(self, value, padding=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: double\n"
		"padding: int\n"
		"\n"
		""},
	 { "DoubleField_getValue", _wrap_DoubleField_getValue, METH_O, "getValue(self) -> double"},
	 { "delete_DoubleField", _wrap_delete_DoubleField, METH_O, "delete_DoubleField(self)"},
	 { "DoubleField_swigregister", DoubleField_swigregister, METH_O, NULL},
	 { "DoubleField_swiginit", DoubleField_swiginit, METH_VARARGS, NULL},
	 { "new_IntField", _wrap_new_IntField, METH_VARARGS, "\n"
		"IntField(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: int\n"
		"\n"
		"new_IntField(field) -> IntField\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "IntField_setValue", _wrap_IntField_setValue, METH_VARARGS, "\n"
		"setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int\n"
		"\n"
		""},
	 { "IntField_getValue", _wrap_IntField_getValue, METH_O, "getValue(self) -> int"},
	 { "delete_IntField", _wrap_delete_IntField, METH_O, "delete_IntField(self)"},
	 { "IntField_swigregister", IntField_swigregister, METH_O, NULL},
	 { "IntField_swiginit", IntField_swiginit, METH_VARARGS, NULL},
	 { "new_Int64Field", _wrap_new_Int64Field, METH_VARARGS, "\n"
		"Int64Field(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: int64_t\n"
		"\n"
		"new_Int64Field(field) -> Int64Field\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "Int64Field_setValue", _wrap_Int64Field_setValue, METH_VARARGS, "\n"
		"setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int64_t\n"
		"\n"
		""},
	 { "Int64Field_getValue", _wrap_Int64Field_getValue, METH_O, "getValue(self) -> int64_t"},
	 { "delete_Int64Field", _wrap_delete_Int64Field, METH_O, "delete_Int64Field(self)"},
	 { "Int64Field_swigregister", Int64Field_swigregister, METH_O, NULL},
	 { "Int64Field_swiginit", Int64Field_swiginit, METH_VARARGS, NULL},
	 { "new_UInt64Field", _wrap_new_UInt64Field, METH_VARARGS, "\n"
		"UInt64Field(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: uint64_t\n"
		"\n"
		"new_UInt64Field(field) -> UInt64Field\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "UInt64Field_setValue", _wrap_UInt64Field_setValue, METH_VARARGS, "\n"
		"setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: uint64_t\n"
		"\n"
		""},
	 { "UInt64Field_getValue", _wrap_UInt64Field_getValue, METH_O, "getValue(self) -> uint64_t"},
	 { "delete_UInt64Field", _wrap_delete_UInt64Field, METH_O, "delete_UInt64Field(self)"},
	 { "UInt64Field_swigregister", UInt64Field_swigregister, METH_O, NULL},
	 { "UInt64Field_swiginit", UInt64Field_swiginit, METH_VARARGS, NULL},
	 { "new_BoolField", _wrap_new_BoolField, METH_VARARGS, "\n"
		"BoolField(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: bool\n"
		"\n"
		"new_BoolField(field) -> BoolField\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "BoolField_setValue", _wrap_BoolField_setValue, METH_VARARGS, "\n"
		"setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "BoolField_getValue", _wrap_BoolField_getValue, METH_O, "getValue(self) -> bool"},
	 { "BoolField___nonzero__", _wrap_BoolField___nonzero__, METH_O, "__nonzero__(self) -> bool"},
	 { "delete_BoolField", _wrap_delete_BoolField, METH_O, "delete_BoolField(self)"},
	 { "BoolField_swigregister", BoolField_swigregister, METH_O, NULL},
	 { "BoolField_swiginit", BoolField_swiginit, METH_VARARGS, NULL},
	 { "new_UtcTimeStampField", _wrap_new_UtcTimeStampField, METH_VARARGS, "\n"
		"UtcTimeStampField(field, data, precision=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: FIX::UtcTimeStamp const &\n"
		"precision: int\n"
		"\n"
		"UtcTimeStampField(field, precision=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "UtcTimeStampField_setValue", _wrap_UtcTimeStampField_setValue, METH_VARARGS, "\n"
		"setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "UtcTimeStampField_getValue", _wrap_UtcTimeStampField_getValue, METH_O, "getValue(self) -> UtcTimeStamp"},
	 { "UtcTimeStampField___lt__", _wrap_UtcTimeStampField___lt__, METH_VARARGS, "\n"
		"__lt__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcTimeStampField const &\n"
		"\n"
		""},
	 { "UtcTimeStampField___eq__", _wrap_UtcTimeStampField___eq__, METH_VARARGS, "\n"
		"__eq__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcTimeStampField const &\n"
		"\n"
		""},
	 { "UtcTimeStampField___ne__", _wrap_UtcTimeStampField___ne__, METH_VARARGS, "\n"
		"__ne__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcTimeStampField const &\n"
		"\n"
		""},
	 { "delete_UtcTimeStampField", _wrap_delete_UtcTimeStampField, METH_O, "delete_UtcTimeStampField(self)"},
	 { "UtcTimeStampField_swigregister", UtcTimeStampField_swigregister, METH_O, NULL},
	 { "UtcTimeStampField_swiginit", UtcTimeStampField_swiginit, METH_VARARGS, NULL},
	 { "new_UtcDateField", _wrap_new_UtcDateField, METH_VARARGS, "\n"
		"UtcDateField(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: FIX::UtcDate const &\n"
		"\n"
		"new_UtcDateField(field) -> UtcDateField\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "UtcDateField_setValue", _wrap_UtcDateField_setValue, METH_VARARGS, "\n"
		"setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::UtcDate const &\n"
		"\n"
		""},
	 { "UtcDateField_getValue", _wrap_UtcDateField_getValue, METH_O, "getValue(self) -> UtcDate"},
	 { "UtcDateField___lt__", _wrap_UtcDateField___lt__, METH_VARARGS, "\n"
		"__lt__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcDateField const &\n"
		"\n"
		""},
	 { "UtcDateField___eq__", _wrap_UtcDateField___eq__, METH_VARARGS, "\n"
		"__eq__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcDateField const &\n"
		"\n"
		""},
	 { "UtcDateField___ne__", _wrap_UtcDateField___ne__, METH_VARARGS, "\n"
		"__ne__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcDateField const &\n"
		"\n"
		""},
	 { "delete_UtcDateField", _wrap_delete_UtcDateField, METH_O, "delete_UtcDateField(self)"},
	 { "UtcDateField_swigregister", UtcDateField_swigregister, METH_O, NULL},
	 { "UtcDateField_swiginit", UtcDateField_swiginit, METH_VARARGS, NULL},
	 { "new_UtcTimeOnlyField", _wrap_new_UtcTimeOnlyField, METH_VARARGS, "\n"
		"UtcTimeOnlyField(field, data, precision=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: FIX::UtcTimeOnly const &\n"
		"precision: int\n"
		"\n"
		"UtcTimeOnlyField(field, precision=0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"precision: int\n"
		"\n"
		""},
	 { "UtcTimeOnlyField_setValue", _wrap_UtcTimeOnlyField_setValue, METH_VARARGS, "\n"
		"setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::UtcTimeOnly const &\n"
		"\n"
		""},
	 { "UtcTimeOnlyField_getValue", _wrap_UtcTimeOnlyField_getValue, METH_O, "getValue(self) -> UtcTimeOnly"},
	 { "UtcTimeOnlyField___lt__", _wrap_UtcTimeOnlyField___lt__, METH_VARARGS, "\n"
		"__lt__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcTimeOnlyField const &\n"
		"\n"
		""},
	 { "UtcTimeOnlyField___eq__", _wrap_UtcTimeOnlyField___eq__, METH_VARARGS, "\n"
		"__eq__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcTimeOnlyField const &\n"
		"\n"
		""},
	 { "UtcTimeOnlyField___ne__", _wrap_UtcTimeOnlyField___ne__, METH_VARARGS, "\n"
		"__ne__(self, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::UtcTimeOnlyField const &\n"
		"\n"
		""},
	 { "delete_UtcTimeOnlyField", _wrap_delete_UtcTimeOnlyField, METH_O, "delete_UtcTimeOnlyField(self)"},
	 { "UtcTimeOnlyField_swigregister", UtcTimeOnlyField_swigregister, METH_O, NULL},
	 { "UtcTimeOnlyField_swiginit", UtcTimeOnlyField_swiginit, METH_VARARGS, NULL},
	 { "new_CheckSumField", _wrap_new_CheckSumField, METH_VARARGS, "\n"
		"CheckSumField(field, data)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"data: int\n"
		"\n"
		"new_CheckSumField(field) -> CheckSumField\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "CheckSumField_setValue", _wrap_CheckSumField_setValue, METH_VARARGS, "\n"
		"setValue(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int\n"
		"\n"
		""},
	 { "CheckSumField_getValue", _wrap_CheckSumField_getValue, METH_O, "getValue(self) -> int"},
	 { "delete_CheckSumField", _wrap_delete_CheckSumField, METH_O, "delete_CheckSumField(self)"},
	 { "CheckSumField_swigregister", CheckSumField_swigregister, METH_O, NULL},
	 { "CheckSumField_swiginit", CheckSumField_swiginit, METH_VARARGS, NULL},
	 { "new_FieldMap", _wrap_new_FieldMap, METH_VARARGS, "\n"
		"FieldMap(order=message_order(message_order::normal))\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"order: message_order const &\n"
		"\n"
		"FieldMap(order)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"order: int const []\n"
		"\n"
		"FieldMap(copy)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"copy: FIX::FieldMap const &\n"
		"\n"
		"new_FieldMap(rhs) -> FieldMap\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rhs: FIX::FieldMap &&\n"
		"\n"
		""},
	 { "delete_FieldMap", _wrap_delete_FieldMap, METH_O, "delete_FieldMap(self)"},
	 { "FieldMap_setField", _wrap_FieldMap_setField, METH_VARARGS, "\n"
		"setField(self, field, overwrite=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: FIX::FieldBase const &\n"
		"overwrite: bool\n"
		"\n"
		"setField(self, tag, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "FieldMap_getFieldIfSet", _wrap_FieldMap_getFieldIfSet, METH_VARARGS, "\n"
		"getFieldIfSet(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: FIX::FieldBase &\n"
		"\n"
		""},
	 { "FieldMap_getField", _wrap_FieldMap_getField, METH_VARARGS, "\n"
		"getField(self, field) -> FieldBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: FIX::FieldBase &\n"
		"\n"
		"getField(self, tag) -> std::string const &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_getFieldRef", _wrap_FieldMap_getFieldRef, METH_VARARGS, "\n"
		"getFieldRef(self, tag) -> FieldBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_getFieldPtr", _wrap_FieldMap_getFieldPtr, METH_VARARGS, "\n"
		"getFieldPtr(self, tag) -> FieldBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_isSetField", _wrap_FieldMap_isSetField, METH_VARARGS, "\n"
		"isSetField(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: FIX::FieldBase const &\n"
		"\n"
		"isSetField(self, tag) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_removeField", _wrap_FieldMap_removeField, METH_VARARGS, "\n"
		"removeField(self, tag)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_addGroup", _wrap_FieldMap_addGroup, METH_VARARGS, "\n"
		"addGroup(self, tag, group, setCount=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"group: FIX::FieldMap const &\n"
		"setCount: bool\n"
		"\n"
		""},
	 { "FieldMap_addGroupPtr", _wrap_FieldMap_addGroupPtr, METH_VARARGS, "\n"
		"addGroupPtr(self, tag, group, setCount=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"group: FIX::FieldMap *\n"
		"setCount: bool\n"
		"\n"
		""},
	 { "FieldMap_replaceGroup", _wrap_FieldMap_replaceGroup, METH_VARARGS, "\n"
		"replaceGroup(self, num, tag, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: int\n"
		"tag: int\n"
		"group: FIX::FieldMap const &\n"
		"\n"
		""},
	 { "FieldMap_getGroup", _wrap_FieldMap_getGroup, METH_VARARGS, "\n"
		"getGroup(self, num, tag, group) -> FieldMap\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: int\n"
		"tag: int\n"
		"group: FIX::FieldMap &\n"
		"\n"
		""},
	 { "FieldMap_getGroupRef", _wrap_FieldMap_getGroupRef, METH_VARARGS, "\n"
		"getGroupRef(self, num, tag) -> FieldMap\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: int\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_getGroupPtr", _wrap_FieldMap_getGroupPtr, METH_VARARGS, "\n"
		"getGroupPtr(self, num, tag) -> FieldMap\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: int\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_groups", _wrap_FieldMap_groups, METH_O, "groups(self) -> FIX::FieldMap::Groups const &"},
	 { "FieldMap_removeGroup", _wrap_FieldMap_removeGroup, METH_VARARGS, "\n"
		"removeGroup(self, num, tag)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: int\n"
		"tag: int\n"
		"\n"
		"removeGroup(self, tag)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_hasGroup", _wrap_FieldMap_hasGroup, METH_VARARGS, "\n"
		"hasGroup(self, tag) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		"hasGroup(self, num, tag) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: int\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_groupCount", _wrap_FieldMap_groupCount, METH_VARARGS, "\n"
		"groupCount(self, tag) -> size_t\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int\n"
		"\n"
		""},
	 { "FieldMap_clear", _wrap_FieldMap_clear, METH_O, "clear(self)"},
	 { "FieldMap_isEmpty", _wrap_FieldMap_isEmpty, METH_O, "isEmpty(self) -> bool"},
	 { "FieldMap_totalFields", _wrap_FieldMap_totalFields, METH_O, "totalFields(self) -> size_t"},
	 { "FieldMap_calculateString", _wrap_FieldMap_calculateString, METH_VARARGS, "\n"
		"calculateString(self, arg2) -> std::string &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string &\n"
		"\n"
		""},
	 { "FieldMap_calculateLength", _wrap_FieldMap_calculateLength, METH_VARARGS, "\n"
		"calculateLength(self, beginStringField=FIELD::BeginString, bodyLengthField=FIELD::BodyLength, checkSumField=FIELD::CheckSum) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"beginStringField: int\n"
		"bodyLengthField: int\n"
		"checkSumField: int\n"
		"\n"
		""},
	 { "FieldMap_calculateTotal", _wrap_FieldMap_calculateTotal, METH_VARARGS, "\n"
		"calculateTotal(self, checkSumField=FIELD::CheckSum) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"checkSumField: int\n"
		"\n"
		""},
	 { "FieldMap_begin", _wrap_FieldMap_begin, METH_VARARGS, "\n"
		"begin(self) -> FIX::FieldMap::iterator\n"
		"begin(self) -> FIX::FieldMap::const_iterator\n"
		""},
	 { "FieldMap_end", _wrap_FieldMap_end, METH_VARARGS, "\n"
		"end(self) -> FIX::FieldMap::iterator\n"
		"end(self) -> FIX::FieldMap::const_iterator\n"
		""},
	 { "FieldMap_g_begin", _wrap_FieldMap_g_begin, METH_VARARGS, "\n"
		"g_begin(self) -> FIX::FieldMap::g_iterator\n"
		"g_begin(self) -> FIX::FieldMap::g_const_iterator\n"
		""},
	 { "FieldMap_g_end", _wrap_FieldMap_g_end, METH_VARARGS, "\n"
		"g_end(self) -> FIX::FieldMap::g_iterator\n"
		"g_end(self) -> FIX::FieldMap::g_const_iterator\n"
		""},
	 { "FieldMap_swigregister", FieldMap_swigregister, METH_O, NULL},
	 { "FieldMap_swiginit", FieldMap_swiginit, METH_VARARGS, NULL},
	 { "new_Header", _wrap_new_Header, METH_VARARGS, "\n"
		"Header()\n"
		"new_Header(order) -> Header\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"order: message_order const &\n"
		"\n"
		""},
	 { "Header_addGroup", _wrap_Header_addGroup, METH_VARARGS, "\n"
		"addGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Header_replaceGroup", _wrap_Header_replaceGroup, METH_VARARGS, "\n"
		"replaceGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Header_getGroup", _wrap_Header_getGroup, METH_VARARGS, "\n"
		"getGroup(self, num, group) -> Group &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group &\n"
		"\n"
		""},
	 { "Header_removeGroup", _wrap_Header_removeGroup, METH_VARARGS, "\n"
		"removeGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		"removeGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Header_hasGroup", _wrap_Header_hasGroup, METH_VARARGS, "\n"
		"hasGroup(self, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		"hasGroup(self, num, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "delete_Header", _wrap_delete_Header, METH_O, "delete_Header(self)"},
	 { "Header_swigregister", Header_swigregister, METH_O, NULL},
	 { "Header_swiginit", Header_swiginit, METH_VARARGS, NULL},
	 { "new_Trailer", _wrap_new_Trailer, METH_VARARGS, "\n"
		"Trailer()\n"
		"new_Trailer(order) -> Trailer\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"order: message_order const &\n"
		"\n"
		""},
	 { "Trailer_addGroup", _wrap_Trailer_addGroup, METH_VARARGS, "\n"
		"addGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Trailer_replaceGroup", _wrap_Trailer_replaceGroup, METH_VARARGS, "\n"
		"replaceGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Trailer_getGroup", _wrap_Trailer_getGroup, METH_VARARGS, "\n"
		"getGroup(self, num, group) -> Group &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group &\n"
		"\n"
		""},
	 { "Trailer_removeGroup", _wrap_Trailer_removeGroup, METH_VARARGS, "\n"
		"removeGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		"removeGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Trailer_hasGroup", _wrap_Trailer_hasGroup, METH_VARARGS, "\n"
		"hasGroup(self, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		"hasGroup(self, num, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "delete_Trailer", _wrap_delete_Trailer, METH_O, "delete_Trailer(self)"},
	 { "Trailer_swigregister", Trailer_swigregister, METH_O, NULL},
	 { "Trailer_swiginit", Trailer_swiginit, METH_VARARGS, NULL},
	 { "new_Message", _wrap_new_Message, METH_VARARGS, "\n"
		"Message()\n"
		"Message(hdrOrder, trlOrder, order)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"hdrOrder: message_order const &\n"
		"trlOrder: message_order const &\n"
		"order: message_order const &\n"
		"\n"
		"Message(string, validate=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"validate: bool\n"
		"\n"
		"Message(string, dataDictionary, validate=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"dataDictionary: FIX::DataDictionary const &\n"
		"validate: bool\n"
		"\n"
		"Message(string, sessionDataDictionary, applicationDataDictionary, validate=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"sessionDataDictionary: FIX::DataDictionary const &\n"
		"applicationDataDictionary: FIX::DataDictionary const &\n"
		"validate: bool\n"
		"\n"
		"Message(headerOrder, trailerOrder, order, string, dataDictionary, validate=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"headerOrder: message_order const &\n"
		"trailerOrder: message_order const &\n"
		"order: message_order const &\n"
		"string: std::string const &\n"
		"dataDictionary: FIX::DataDictionary const &\n"
		"validate: bool\n"
		"\n"
		"Message(headerOrder, trailerOrder, order, string, sessionDataDictionary, applicationDataDictionary, validate=True)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"headerOrder: message_order const &\n"
		"trailerOrder: message_order const &\n"
		"order: message_order const &\n"
		"string: std::string const &\n"
		"sessionDataDictionary: FIX::DataDictionary const &\n"
		"applicationDataDictionary: FIX::DataDictionary const &\n"
		"validate: bool\n"
		"\n"
		"Message(arg1)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Message const &\n"
		"\n"
		"new_Message(arg1) -> Message\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Message &&\n"
		"\n"
		""},
	 { "delete_Message", _wrap_delete_Message, METH_O, "delete_Message(self)"},
	 { "Message_InitializeXML", _wrap_Message_InitializeXML, METH_O, "\n"
		"InitializeXML(string) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"\n"
		""},
	 { "Message_addGroup", _wrap_Message_addGroup, METH_VARARGS, "\n"
		"addGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Message_replaceGroup", _wrap_Message_replaceGroup, METH_VARARGS, "\n"
		"replaceGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Message_getGroup", _wrap_Message_getGroup, METH_VARARGS, "\n"
		"getGroup(self, num, group) -> Group &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group &\n"
		"\n"
		""},
	 { "Message_removeGroup", _wrap_Message_removeGroup, METH_VARARGS, "\n"
		"removeGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		"removeGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Message_hasGroup", _wrap_Message_hasGroup, METH_VARARGS, "\n"
		"hasGroup(self, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		"hasGroup(self, num, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Message_toString", _wrap_Message_toString, METH_VARARGS, "\n"
		"toString(self, beginStringField=FIELD::BeginString, bodyLengthField=FIELD::BodyLength, checkSumField=FIELD::CheckSum) -> std::string\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"beginStringField: int\n"
		"bodyLengthField: int\n"
		"checkSumField: int\n"
		"\n"
		"toString(self, arg2, beginStringField=FIELD::BeginString, bodyLengthField=FIELD::BodyLength, checkSumField=FIELD::CheckSum) -> std::string\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string &\n"
		"beginStringField: int\n"
		"bodyLengthField: int\n"
		"checkSumField: int\n"
		"\n"
		""},
	 { "Message_toXML", _wrap_Message_toXML, METH_VARARGS, "\n"
		"toXML(self) -> std::string\n"
		"toXML(self, arg2) -> std::string &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string &\n"
		"\n"
		""},
	 { "Message_reverseRoute", _wrap_Message_reverseRoute, METH_VARARGS, "\n"
		"reverseRoute(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::Header const &\n"
		"\n"
		""},
	 { "Message_setString", _wrap_Message_setString, METH_VARARGS, "\n"
		"setString(self, string)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"\n"
		"setString(self, string, validate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"validate: bool\n"
		"\n"
		"setString(self, string, validate, pDataDictionary)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"validate: bool\n"
		"pDataDictionary: FIX::DataDictionary const *\n"
		"\n"
		"setString(self, string, validate, pSessionDataDictionary, pApplicationDataDictionary)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"validate: bool\n"
		"pSessionDataDictionary: FIX::DataDictionary const *\n"
		"pApplicationDataDictionary: FIX::DataDictionary const *\n"
		"\n"
		""},
	 { "Message_setGroup", _wrap_Message_setGroup, METH_VARARGS, "\n"
		"setGroup(self, msg, field, string, pos, map, dataDictionary)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msg: std::string const &\n"
		"field: FIX::FieldBase const &\n"
		"string: std::string const &\n"
		"pos: std::string::size_type &\n"
		"map: FIX::FieldMap &\n"
		"dataDictionary: DataDictionary const &\n"
		"\n"
		""},
	 { "Message_setStringHeader", _wrap_Message_setStringHeader, METH_VARARGS, "\n"
		"setStringHeader(self, string) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string: std::string const &\n"
		"\n"
		""},
	 { "Message_getHeader", _wrap_Message_getHeader, METH_VARARGS, "\n"
		"getHeader(self) -> Header\n"
		"getHeader(self) -> Header\n"
		""},
	 { "Message_getTrailer", _wrap_Message_getTrailer, METH_VARARGS, "\n"
		"getTrailer(self) -> Trailer\n"
		"getTrailer(self) -> Trailer\n"
		""},
	 { "Message_hasValidStructure", _wrap_Message_hasValidStructure, METH_VARARGS, "\n"
		"hasValidStructure(self, tag) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tag: int &\n"
		"\n"
		""},
	 { "Message_bodyLength", _wrap_Message_bodyLength, METH_VARARGS, "\n"
		"bodyLength(self, beginStringField=FIELD::BeginString, bodyLengthField=FIELD::BodyLength, checkSumField=FIELD::CheckSum) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"beginStringField: int\n"
		"bodyLengthField: int\n"
		"checkSumField: int\n"
		"\n"
		""},
	 { "Message_checkSum", _wrap_Message_checkSum, METH_VARARGS, "\n"
		"checkSum(self, checkSumField=FIELD::CheckSum) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"checkSumField: int\n"
		"\n"
		""},
	 { "Message_isAdmin", _wrap_Message_isAdmin, METH_O, "isAdmin(self) -> bool"},
	 { "Message_isApp", _wrap_Message_isApp, METH_O, "isApp(self) -> bool"},
	 { "Message_isEmpty", _wrap_Message_isEmpty, METH_O, "isEmpty(self) -> bool"},
	 { "Message_clear", _wrap_Message_clear, METH_O, "clear(self)"},
	 { "Message_isAdminMsgType", _wrap_Message_isAdminMsgType, METH_O, "\n"
		"isAdminMsgType(msgType) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: MsgType const &\n"
		"\n"
		""},
	 { "Message_toApplVerID", _wrap_Message_toApplVerID, METH_O, "\n"
		"toApplVerID(value) -> ApplVerID\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: BeginString const &\n"
		"\n"
		""},
	 { "Message_toBeginString", _wrap_Message_toBeginString, METH_O, "\n"
		"toBeginString(applVerID) -> BeginString\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"applVerID: ApplVerID const &\n"
		"\n"
		""},
	 { "Message_isHeaderField", _wrap_Message_isHeaderField, METH_VARARGS, "\n"
		"isHeaderField(field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		"isHeaderField(field, pD=None) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: FIX::FieldBase const &\n"
		"pD: DataDictionary const *\n"
		"\n"
		"isHeaderField(field, pD) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"pD: DataDictionary const *\n"
		"\n"
		""},
	 { "Message_isTrailerField", _wrap_Message_isTrailerField, METH_VARARGS, "\n"
		"isTrailerField(field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		"isTrailerField(field, pD=None) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: FIX::FieldBase const &\n"
		"pD: DataDictionary const *\n"
		"\n"
		"isTrailerField(field, pD) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"pD: DataDictionary const *\n"
		"\n"
		""},
	 { "Message_getSessionID", _wrap_Message_getSessionID, METH_VARARGS, "\n"
		"getSessionID(self, qualifier=\"\") -> SessionID\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"qualifier: std::string const &\n"
		"\n"
		""},
	 { "Message_setSessionID", _wrap_Message_setSessionID, METH_VARARGS, "\n"
		"setSessionID(self, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: SessionID const &\n"
		"\n"
		""},
	 { "Message___str__", _wrap_Message___str__, METH_O, "__str__(self) -> std::string"},
	 { "Message_swigregister", Message_swigregister, METH_O, NULL},
	 { "Message_swiginit", Message_swiginit, METH_VARARGS, NULL},
	 { "identifyType", _wrap_identifyType, METH_O, "\n"
		"identifyType(message) -> MsgType\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: std::string const &\n"
		"\n"
		""},
	 { "new_Group", _wrap_new_Group, METH_VARARGS, "\n"
		"Group(field, delim)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"delim: int\n"
		"\n"
		"Group(field, delim, order)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"delim: int\n"
		"order: int const []\n"
		"\n"
		"Group(field, delim, order)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"delim: int\n"
		"order: message_order const &\n"
		"\n"
		"new_Group(copy) -> Group\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"copy: FIX::Group const &\n"
		"\n"
		""},
	 { "Group_field", _wrap_Group_field, METH_O, "field(self) -> int"},
	 { "Group_delim", _wrap_Group_delim, METH_O, "delim(self) -> int"},
	 { "Group_addGroup", _wrap_Group_addGroup, METH_VARARGS, "\n"
		"addGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Group_replaceGroup", _wrap_Group_replaceGroup, METH_VARARGS, "\n"
		"replaceGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Group_getGroup", _wrap_Group_getGroup, METH_VARARGS, "\n"
		"getGroup(self, num, group) -> Group\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group &\n"
		"\n"
		""},
	 { "Group_removeGroup", _wrap_Group_removeGroup, METH_VARARGS, "\n"
		"removeGroup(self, num, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		"removeGroup(self, group)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "Group_hasGroup", _wrap_Group_hasGroup, METH_VARARGS, "\n"
		"hasGroup(self, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"group: FIX::Group const &\n"
		"\n"
		"hasGroup(self, num, group) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: unsigned int\n"
		"group: FIX::Group const &\n"
		"\n"
		""},
	 { "delete_Group", _wrap_delete_Group, METH_O, "delete_Group(self)"},
	 { "Group_swigregister", Group_swigregister, METH_O, NULL},
	 { "Group_swiginit", Group_swiginit, METH_VARARGS, NULL},
	 { "new_BeginString", _wrap_new_BeginString, METH_VARARGS, "\n"
		"BeginString()\n"
		"new_BeginString(value) -> BeginString\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::STRING const &\n"
		"\n"
		""},
	 { "delete_BeginString", _wrap_delete_BeginString, METH_O, "delete_BeginString(self)"},
	 { "BeginString_swigregister", BeginString_swigregister, METH_O, NULL},
	 { "BeginString_swiginit", BeginString_swiginit, METH_VARARGS, NULL},
	 { "new_SenderCompID", _wrap_new_SenderCompID, METH_VARARGS, "\n"
		"SenderCompID()\n"
		"new_SenderCompID(value) -> SenderCompID\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::STRING const &\n"
		"\n"
		""},
	 { "delete_SenderCompID", _wrap_delete_SenderCompID, METH_O, "delete_SenderCompID(self)"},
	 { "SenderCompID_swigregister", SenderCompID_swigregister, METH_O, NULL},
	 { "SenderCompID_swiginit", SenderCompID_swiginit, METH_VARARGS, NULL},
	 { "new_TargetCompID", _wrap_new_TargetCompID, METH_VARARGS, "\n"
		"TargetCompID()\n"
		"new_TargetCompID(value) -> TargetCompID\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::STRING const &\n"
		"\n"
		""},
	 { "delete_TargetCompID", _wrap_delete_TargetCompID, METH_O, "delete_TargetCompID(self)"},
	 { "TargetCompID_swigregister", TargetCompID_swigregister, METH_O, NULL},
	 { "TargetCompID_swiginit", TargetCompID_swiginit, METH_VARARGS, NULL},
	 { "new_SessionID", _wrap_new_SessionID, METH_VARARGS, "\n"
		"SessionID()\n"
		"SessionID(beginString, senderCompID, targetCompID, sessionQualifier=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"beginString: std::string const &\n"
		"senderCompID: std::string const &\n"
		"targetCompID: std::string const &\n"
		"sessionQualifier: std::string const &\n"
		"\n"
		""},
	 { "SessionID_getBeginString", _wrap_SessionID_getBeginString, METH_O, "getBeginString(self) -> BeginString"},
	 { "SessionID_getSenderCompID", _wrap_SessionID_getSenderCompID, METH_O, "getSenderCompID(self) -> SenderCompID"},
	 { "SessionID_getTargetCompID", _wrap_SessionID_getTargetCompID, METH_O, "getTargetCompID(self) -> TargetCompID"},
	 { "SessionID_getSessionQualifier", _wrap_SessionID_getSessionQualifier, METH_O, "getSessionQualifier(self) -> std::string const &"},
	 { "SessionID_isFIXT", _wrap_SessionID_isFIXT, METH_O, "isFIXT(self) -> bool const"},
	 { "SessionID_toStringFrozen", _wrap_SessionID_toStringFrozen, METH_O, "toStringFrozen(self) -> std::string const &"},
	 { "SessionID_fromString", _wrap_SessionID_fromString, METH_VARARGS, "\n"
		"fromString(self, str)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"str: std::string const &\n"
		"\n"
		""},
	 { "SessionID_toString", _wrap_SessionID_toString, METH_VARARGS, "\n"
		"toString(self) -> std::string\n"
		"toString(self, str) -> std::string &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"str: std::string &\n"
		"\n"
		""},
	 { "SessionID___invert__", _wrap_SessionID___invert__, METH_O, "__invert__(self) -> SessionID"},
	 { "SessionID___str__", _wrap_SessionID___str__, METH_O, "__str__(self) -> std::string"},
	 { "delete_SessionID", _wrap_delete_SessionID, METH_O, "delete_SessionID(self)"},
	 { "SessionID_swigregister", SessionID_swigregister, METH_O, NULL},
	 { "SessionID_swiginit", SessionID_swiginit, METH_VARARGS, NULL},
	 { "new_Dictionary", _wrap_new_Dictionary, METH_VARARGS, "\n"
		"Dictionary(name)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name: std::string const &\n"
		"\n"
		"new_Dictionary() -> Dictionary\n"
		""},
	 { "delete_Dictionary", _wrap_delete_Dictionary, METH_O, "delete_Dictionary(self)"},
	 { "Dictionary_getName", _wrap_Dictionary_getName, METH_O, "getName(self) -> std::string"},
	 { "Dictionary_size", _wrap_Dictionary_size, METH_O, "size(self) -> size_t"},
	 { "Dictionary_getString", _wrap_Dictionary_getString, METH_VARARGS, "\n"
		"getString(self, arg2, capitalize=False) -> std::string\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"capitalize: bool\n"
		"\n"
		""},
	 { "Dictionary_getInt", _wrap_Dictionary_getInt, METH_VARARGS, "\n"
		"getInt(self, arg2) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "Dictionary_getDouble", _wrap_Dictionary_getDouble, METH_VARARGS, "\n"
		"getDouble(self, arg2) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "Dictionary_getBool", _wrap_Dictionary_getBool, METH_VARARGS, "\n"
		"getBool(self, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "Dictionary_getDay", _wrap_Dictionary_getDay, METH_VARARGS, "\n"
		"getDay(self, arg2) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "Dictionary_setString", _wrap_Dictionary_setString, METH_VARARGS, "\n"
		"setString(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"arg3: std::string const &\n"
		"\n"
		""},
	 { "Dictionary_setInt", _wrap_Dictionary_setInt, METH_VARARGS, "\n"
		"setInt(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"arg3: int\n"
		"\n"
		""},
	 { "Dictionary_setDouble", _wrap_Dictionary_setDouble, METH_VARARGS, "\n"
		"setDouble(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"arg3: double\n"
		"\n"
		""},
	 { "Dictionary_setBool", _wrap_Dictionary_setBool, METH_VARARGS, "\n"
		"setBool(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"arg3: bool\n"
		"\n"
		""},
	 { "Dictionary_setDay", _wrap_Dictionary_setDay, METH_VARARGS, "\n"
		"setDay(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"arg3: int\n"
		"\n"
		""},
	 { "Dictionary_has", _wrap_Dictionary_has, METH_VARARGS, "\n"
		"has(self, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "Dictionary_merge", _wrap_Dictionary_merge, METH_VARARGS, "\n"
		"merge(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::Dictionary const &\n"
		"\n"
		""},
	 { "Dictionary_begin", _wrap_Dictionary_begin, METH_O, "begin(self) -> FIX::Dictionary::iterator"},
	 { "Dictionary_end", _wrap_Dictionary_end, METH_O, "end(self) -> FIX::Dictionary::iterator"},
	 { "Dictionary_swigregister", Dictionary_swigregister, METH_O, NULL},
	 { "Dictionary_swiginit", Dictionary_swiginit, METH_VARARGS, NULL},
	 { "new_SessionSettings", _wrap_new_SessionSettings, METH_VARARGS, "\n"
		"SessionSettings()\n"
		"SessionSettings(stream, resolveEnvVars=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"stream: std::istream &\n"
		"resolveEnvVars: bool\n"
		"\n"
		"SessionSettings(file, resolveEnvVars=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"file: std::string const &\n"
		"resolveEnvVars: bool\n"
		"\n"
		""},
	 { "SessionSettings_has", _wrap_SessionSettings_has, METH_VARARGS, "\n"
		"has(self, arg2) -> bool const\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SessionSettings_get", _wrap_SessionSettings_get, METH_VARARGS, "\n"
		"get(self, arg2) -> Dictionary\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		"get(self) -> Dictionary\n"
		""},
	 { "SessionSettings_set", _wrap_SessionSettings_set, METH_VARARGS, "\n"
		"set(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SessionID const &\n"
		"arg3: FIX::Dictionary\n"
		"\n"
		"set(self, defaults)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"defaults: FIX::Dictionary const &\n"
		"\n"
		""},
	 { "SessionSettings_size", _wrap_SessionSettings_size, METH_O, "size(self) -> size_t"},
	 { "SessionSettings_getSessions", _wrap_SessionSettings_getSessions, METH_O, "getSessions(self) -> SessionIDSet"},
	 { "__rshift__", _wrap___rshift__, METH_VARARGS, "\n"
		"__rshift__(arg1, arg2) -> std::istream\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::istream &\n"
		"arg2: FIX::SessionID &\n"
		"\n"
		"__rshift__(arg1, arg2) -> std::istream &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::istream &\n"
		"arg2: FIX::SessionSettings &\n"
		"\n"
		""},
	 { "__lshift__", _wrap___lshift__, METH_VARARGS, "\n"
		"__lshift__(stream, field) -> std::ostream\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"stream: std::ostream &\n"
		"field: FIX::FieldBase const &\n"
		"\n"
		"__lshift__(stream, message) -> std::ostream\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"stream: std::ostream &\n"
		"message: FIX::Message const &\n"
		"\n"
		"__lshift__(arg1, arg2) -> std::ostream\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::ostream &\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		"__lshift__(arg1, arg2) -> std::ostream &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::ostream &\n"
		"arg2: FIX::SessionSettings const &\n"
		"\n"
		""},
	 { "SessionSettings_setFromString", _wrap_SessionSettings_setFromString, METH_VARARGS, "\n"
		"setFromString(self, str)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"str: std::string const &\n"
		"\n"
		""},
	 { "delete_SessionSettings", _wrap_delete_SessionSettings, METH_O, "delete_SessionSettings(self)"},
	 { "SessionSettings_swigregister", SessionSettings_swigregister, METH_O, NULL},
	 { "SessionSettings_swiginit", SessionSettings_swiginit, METH_VARARGS, NULL},
	 { "new_Session", _wrap_new_Session, METH_VARARGS, "\n"
		"new_Session(timestamper, arg2, arg3, arg4, arg5, arg6, heartBtInt, pLogFactory) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"timestamper: std::function< FIX::UtcTimeStamp () >\n"
		"arg2: Application &\n"
		"arg3: MessageStoreFactory &\n"
		"arg4: FIX::SessionID const &\n"
		"arg5: DataDictionaryProvider const &\n"
		"arg6: TimeRange const &\n"
		"heartBtInt: int\n"
		"pLogFactory: LogFactory *\n"
		"\n"
		""},
	 { "delete_Session", _wrap_delete_Session, METH_O, "delete_Session(self)"},
	 { "Session_logon", _wrap_Session_logon, METH_O, "logon(self)"},
	 { "Session_logout", _wrap_Session_logout, METH_VARARGS, "\n"
		"logout(self, reason=\"\")\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"reason: std::string const &\n"
		"\n"
		""},
	 { "Session_isEnabled", _wrap_Session_isEnabled, METH_O, "isEnabled(self) -> bool"},
	 { "Session_sentLogon", _wrap_Session_sentLogon, METH_O, "sentLogon(self) -> bool"},
	 { "Session_sentLogout", _wrap_Session_sentLogout, METH_O, "sentLogout(self) -> bool"},
	 { "Session_receivedLogon", _wrap_Session_receivedLogon, METH_O, "receivedLogon(self) -> bool"},
	 { "Session_isLoggedOn", _wrap_Session_isLoggedOn, METH_O, "isLoggedOn(self) -> bool"},
	 { "Session_reset", _wrap_Session_reset, METH_O, "reset(self)"},
	 { "Session_refresh", _wrap_Session_refresh, METH_O, "refresh(self)"},
	 { "Session_setNextSenderMsgSeqNum", _wrap_Session_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"setNextSenderMsgSeqNum(self, num)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: FIX::SEQNUM\n"
		"\n"
		""},
	 { "Session_setNextTargetMsgSeqNum", _wrap_Session_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"setNextTargetMsgSeqNum(self, num)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num: FIX::SEQNUM\n"
		"\n"
		""},
	 { "Session_getSessionID", _wrap_Session_getSessionID, METH_O, "getSessionID(self) -> SessionID"},
	 { "Session_setDataDictionaryProvider", _wrap_Session_setDataDictionaryProvider, METH_VARARGS, "\n"
		"setDataDictionaryProvider(self, dataDictionaryProvider)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dataDictionaryProvider: DataDictionaryProvider const &\n"
		"\n"
		""},
	 { "Session_getDataDictionaryProvider", _wrap_Session_getDataDictionaryProvider, METH_O, "getDataDictionaryProvider(self) -> DataDictionaryProvider const &"},
	 { "Session_sendToTarget", _wrap_Session_sendToTarget, METH_VARARGS, "\n"
		"sendToTarget(message, qualifier=\"\") -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message &\n"
		"qualifier: std::string const &\n"
		"\n"
		"sendToTarget(message, sessionID) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message &\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		"sendToTarget(arg1, senderCompID, targetCompID, qualifier=\"\") -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Message &\n"
		"senderCompID: FIX::SenderCompID const &\n"
		"targetCompID: FIX::TargetCompID const &\n"
		"qualifier: std::string const &\n"
		"\n"
		"sendToTarget(message, senderCompID, targetCompID, qualifier=\"\") -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message &\n"
		"senderCompID: std::string const &\n"
		"targetCompID: std::string const &\n"
		"qualifier: std::string const &\n"
		"\n"
		""},
	 { "Session_getSessions", _wrap_Session_getSessions, METH_NOARGS, "getSessions() -> SessionIDSet"},
	 { "Session_doesSessionExist", _wrap_Session_doesSessionExist, METH_O, "\n"
		"doesSessionExist(arg1) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Session_lookupSession", _wrap_Session_lookupSession, METH_VARARGS, "\n"
		"lookupSession(arg1) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		"lookupSession(arg1, reverse=False) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::string const &\n"
		"reverse: bool\n"
		"\n"
		""},
	 { "Session_isSessionRegistered", _wrap_Session_isSessionRegistered, METH_O, "\n"
		"isSessionRegistered(arg1) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Session_registerSession", _wrap_Session_registerSession, METH_O, "\n"
		"registerSession(arg1) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Session_unregisterSession", _wrap_Session_unregisterSession, METH_O, "\n"
		"unregisterSession(arg1)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Session_numSessions", _wrap_Session_numSessions, METH_NOARGS, "numSessions() -> size_t"},
	 { "Session_isSessionTime", _wrap_Session_isSessionTime, METH_VARARGS, "\n"
		"isSessionTime(self, now) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "Session_isLogonTime", _wrap_Session_isLogonTime, METH_VARARGS, "\n"
		"isLogonTime(self, now) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "Session_isInitiator", _wrap_Session_isInitiator, METH_O, "isInitiator(self) -> bool"},
	 { "Session_isAcceptor", _wrap_Session_isAcceptor, METH_O, "isAcceptor(self) -> bool"},
	 { "Session_getLogonTime", _wrap_Session_getLogonTime, METH_O, "getLogonTime(self) -> TimeRange const &"},
	 { "Session_setLogonTime", _wrap_Session_setLogonTime, METH_VARARGS, "\n"
		"setLogonTime(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: TimeRange const &\n"
		"\n"
		""},
	 { "Session_getSenderDefaultApplVerID", _wrap_Session_getSenderDefaultApplVerID, METH_O, "getSenderDefaultApplVerID(self) -> std::string const &"},
	 { "Session_setSenderDefaultApplVerID", _wrap_Session_setSenderDefaultApplVerID, METH_VARARGS, "\n"
		"setSenderDefaultApplVerID(self, senderDefaultApplVerID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"senderDefaultApplVerID: std::string const &\n"
		"\n"
		""},
	 { "Session_getTargetDefaultApplVerID", _wrap_Session_getTargetDefaultApplVerID, METH_O, "getTargetDefaultApplVerID(self) -> std::string const &"},
	 { "Session_setTargetDefaultApplVerID", _wrap_Session_setTargetDefaultApplVerID, METH_VARARGS, "\n"
		"setTargetDefaultApplVerID(self, targetDefaultApplVerID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"targetDefaultApplVerID: std::string const &\n"
		"\n"
		""},
	 { "Session_getSendRedundantResendRequests", _wrap_Session_getSendRedundantResendRequests, METH_O, "getSendRedundantResendRequests(self) -> bool"},
	 { "Session_setSendRedundantResendRequests", _wrap_Session_setSendRedundantResendRequests, METH_VARARGS, "\n"
		"setSendRedundantResendRequests(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getCheckCompId", _wrap_Session_getCheckCompId, METH_O, "getCheckCompId(self) -> bool"},
	 { "Session_setCheckCompId", _wrap_Session_setCheckCompId, METH_VARARGS, "\n"
		"setCheckCompId(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getCheckLatency", _wrap_Session_getCheckLatency, METH_O, "getCheckLatency(self) -> bool"},
	 { "Session_setCheckLatency", _wrap_Session_setCheckLatency, METH_VARARGS, "\n"
		"setCheckLatency(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getMaxLatency", _wrap_Session_getMaxLatency, METH_O, "getMaxLatency(self) -> int"},
	 { "Session_setMaxLatency", _wrap_Session_setMaxLatency, METH_VARARGS, "\n"
		"setMaxLatency(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int\n"
		"\n"
		""},
	 { "Session_getLogonTimeout", _wrap_Session_getLogonTimeout, METH_O, "getLogonTimeout(self) -> int"},
	 { "Session_setLogonTimeout", _wrap_Session_setLogonTimeout, METH_VARARGS, "\n"
		"setLogonTimeout(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int\n"
		"\n"
		""},
	 { "Session_getLogoutTimeout", _wrap_Session_getLogoutTimeout, METH_O, "getLogoutTimeout(self) -> int"},
	 { "Session_setLogoutTimeout", _wrap_Session_setLogoutTimeout, METH_VARARGS, "\n"
		"setLogoutTimeout(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: int\n"
		"\n"
		""},
	 { "Session_getResetOnLogon", _wrap_Session_getResetOnLogon, METH_O, "getResetOnLogon(self) -> bool"},
	 { "Session_setResetOnLogon", _wrap_Session_setResetOnLogon, METH_VARARGS, "\n"
		"setResetOnLogon(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getResetOnLogout", _wrap_Session_getResetOnLogout, METH_O, "getResetOnLogout(self) -> bool"},
	 { "Session_setResetOnLogout", _wrap_Session_setResetOnLogout, METH_VARARGS, "\n"
		"setResetOnLogout(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getResetOnDisconnect", _wrap_Session_getResetOnDisconnect, METH_O, "getResetOnDisconnect(self) -> bool"},
	 { "Session_setResetOnDisconnect", _wrap_Session_setResetOnDisconnect, METH_VARARGS, "\n"
		"setResetOnDisconnect(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getRefreshOnLogon", _wrap_Session_getRefreshOnLogon, METH_O, "getRefreshOnLogon(self) -> bool"},
	 { "Session_setRefreshOnLogon", _wrap_Session_setRefreshOnLogon, METH_VARARGS, "\n"
		"setRefreshOnLogon(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getMillisecondsInTimeStamp", _wrap_Session_getMillisecondsInTimeStamp, METH_O, "getMillisecondsInTimeStamp(self) -> bool"},
	 { "Session_setMillisecondsInTimeStamp", _wrap_Session_setMillisecondsInTimeStamp, METH_VARARGS, "\n"
		"setMillisecondsInTimeStamp(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getTimestampPrecision", _wrap_Session_getTimestampPrecision, METH_O, "getTimestampPrecision(self) -> int"},
	 { "Session_setTimestampPrecision", _wrap_Session_setTimestampPrecision, METH_VARARGS, "\n"
		"setTimestampPrecision(self, precision)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"precision: int\n"
		"\n"
		""},
	 { "Session_getSupportedTimestampPrecision", _wrap_Session_getSupportedTimestampPrecision, METH_O, "getSupportedTimestampPrecision(self) -> int"},
	 { "Session_supportsSubSecondTimestamps", _wrap_Session_supportsSubSecondTimestamps, METH_O, "\n"
		"supportsSubSecondTimestamps(beginString) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"beginString: std::string const &\n"
		"\n"
		""},
	 { "Session_getPersistMessages", _wrap_Session_getPersistMessages, METH_O, "getPersistMessages(self) -> bool"},
	 { "Session_setPersistMessages", _wrap_Session_setPersistMessages, METH_VARARGS, "\n"
		"setPersistMessages(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getValidateLengthAndChecksum", _wrap_Session_getValidateLengthAndChecksum, METH_O, "getValidateLengthAndChecksum(self) -> bool"},
	 { "Session_setValidateLengthAndChecksum", _wrap_Session_setValidateLengthAndChecksum, METH_VARARGS, "\n"
		"setValidateLengthAndChecksum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getSendNextExpectedMsgSeqNum", _wrap_Session_getSendNextExpectedMsgSeqNum, METH_O, "getSendNextExpectedMsgSeqNum(self) -> bool"},
	 { "Session_setSendNextExpectedMsgSeqNum", _wrap_Session_setSendNextExpectedMsgSeqNum, METH_VARARGS, "\n"
		"setSendNextExpectedMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getIsNonStopSession", _wrap_Session_getIsNonStopSession, METH_O, "getIsNonStopSession(self) -> bool"},
	 { "Session_setIsNonStopSession", _wrap_Session_setIsNonStopSession, METH_VARARGS, "\n"
		"setIsNonStopSession(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "Session_getAllowedRemoteAddresses", _wrap_Session_getAllowedRemoteAddresses, METH_O, "getAllowedRemoteAddresses(self) -> std::set< std::string,std::less< std::string >,std::allocator< std::string > > const &"},
	 { "Session_setAllowedRemoteAddresses", _wrap_Session_setAllowedRemoteAddresses, METH_VARARGS, "\n"
		"setAllowedRemoteAddresses(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::set< std::string,std::less< std::string >,std::allocator< std::string > > const &\n"
		"\n"
		""},
	 { "Session_inAllowedRemoteAddresses", _wrap_Session_inAllowedRemoteAddresses, METH_VARARGS, "\n"
		"inAllowedRemoteAddresses(self, value) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "Session_setResponder", _wrap_Session_setResponder, METH_VARARGS, "\n"
		"setResponder(self, pR)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pR: Responder *\n"
		"\n"
		""},
	 { "Session_send", _wrap_Session_send, METH_VARARGS, "\n"
		"send(self, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::Message &\n"
		"\n"
		""},
	 { "Session_next", _wrap_Session_next, METH_VARARGS, "\n"
		"next(self, now)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		"next(self, arg2, now, queued=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"now: FIX::UtcTimeStamp const &\n"
		"queued: bool\n"
		"\n"
		"next(self, arg2, now, queued=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::Message const &\n"
		"now: FIX::UtcTimeStamp const &\n"
		"queued: bool\n"
		"\n"
		""},
	 { "Session_disconnect", _wrap_Session_disconnect, METH_O, "disconnect(self)"},
	 { "Session_getExpectedSenderNum", _wrap_Session_getExpectedSenderNum, METH_O, "getExpectedSenderNum(self) -> FIX::SEQNUM"},
	 { "Session_getExpectedTargetNum", _wrap_Session_getExpectedTargetNum, METH_O, "getExpectedTargetNum(self) -> FIX::SEQNUM"},
	 { "Session_getLog", _wrap_Session_getLog, METH_O, "getLog(self) -> Log *"},
	 { "Session_getStore", _wrap_Session_getStore, METH_O, "getStore(self) -> MessageStore const *"},
	 { "Session_swigregister", Session_swigregister, METH_O, NULL},
	 { "Session_swiginit", Session_swiginit, METH_VARARGS, NULL},
	 { "delete_LogFactory", _wrap_delete_LogFactory, METH_O, "delete_LogFactory(self)"},
	 { "LogFactory_create", _wrap_LogFactory_create, METH_VARARGS, "\n"
		"create(self) -> Log\n"
		"create(self, arg0) -> Log\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::SessionID const &\n"
		"\n"
		""},
	 { "LogFactory_destroy", _wrap_LogFactory_destroy, METH_VARARGS, "\n"
		"destroy(self, arg0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::Log *\n"
		"\n"
		""},
	 { "new_LogFactory", _wrap_new_LogFactory, METH_O, "\n"
		"new_LogFactory(_self) -> LogFactory\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"self: PyObject *\n"
		"\n"
		""},
	 { "disown_LogFactory", _wrap_disown_LogFactory, METH_O, NULL},
	 { "LogFactory_swigregister", LogFactory_swigregister, METH_O, NULL},
	 { "LogFactory_swiginit", LogFactory_swiginit, METH_VARARGS, NULL},
	 { "new_ScreenLogFactory", _wrap_new_ScreenLogFactory, METH_VARARGS, "\n"
		"ScreenLogFactory(settings)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"settings: FIX::SessionSettings\n"
		"\n"
		"new_ScreenLogFactory(incoming, outgoing, event) -> ScreenLogFactory\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"incoming: bool\n"
		"outgoing: bool\n"
		"event: bool\n"
		"\n"
		""},
	 { "ScreenLogFactory_create", _wrap_ScreenLogFactory_create, METH_VARARGS, "\n"
		"create(self) -> Log\n"
		"create(self, arg2) -> Log\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		""},
	 { "ScreenLogFactory_destroy", _wrap_ScreenLogFactory_destroy, METH_VARARGS, "\n"
		"destroy(self, log)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"log: FIX::Log *\n"
		"\n"
		""},
	 { "delete_ScreenLogFactory", _wrap_delete_ScreenLogFactory, METH_O, "delete_ScreenLogFactory(self)"},
	 { "ScreenLogFactory_swigregister", ScreenLogFactory_swigregister, METH_O, NULL},
	 { "ScreenLogFactory_swiginit", ScreenLogFactory_swiginit, METH_VARARGS, NULL},
	 { "delete_Log", _wrap_delete_Log, METH_O, "delete_Log(self)"},
	 { "Log_clear", _wrap_Log_clear, METH_O, "clear(self)"},
	 { "Log_backup", _wrap_Log_backup, METH_O, "backup(self)"},
	 { "Log_onIncoming", _wrap_Log_onIncoming, METH_VARARGS, "\n"
		"onIncoming(self, arg0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: std::string const &\n"
		"\n"
		""},
	 { "Log_onOutgoing", _wrap_Log_onOutgoing, METH_VARARGS, "\n"
		"onOutgoing(self, arg0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: std::string const &\n"
		"\n"
		""},
	 { "Log_onEvent", _wrap_Log_onEvent, METH_VARARGS, "\n"
		"onEvent(self, arg0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: std::string const &\n"
		"\n"
		""},
	 { "new_Log", _wrap_new_Log, METH_O, "\n"
		"new_Log(_self) -> Log\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"self: PyObject *\n"
		"\n"
		""},
	 { "disown_Log", _wrap_disown_Log, METH_O, NULL},
	 { "Log_swigregister", Log_swigregister, METH_O, NULL},
	 { "Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
	 { "NullLog_clear", _wrap_NullLog_clear, METH_O, "clear(self)"},
	 { "NullLog_backup", _wrap_NullLog_backup, METH_O, "backup(self)"},
	 { "NullLog_onIncoming", _wrap_NullLog_onIncoming, METH_VARARGS, "\n"
		"onIncoming(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "NullLog_onOutgoing", _wrap_NullLog_onOutgoing, METH_VARARGS, "\n"
		"onOutgoing(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "NullLog_onEvent", _wrap_NullLog_onEvent, METH_VARARGS, "\n"
		"onEvent(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: std::string const &\n"
		"\n"
		""},
	 { "new_NullLog", _wrap_new_NullLog, METH_NOARGS, "new_NullLog() -> NullLog"},
	 { "delete_NullLog", _wrap_delete_NullLog, METH_O, "delete_NullLog(self)"},
	 { "NullLog_swigregister", NullLog_swigregister, METH_O, NULL},
	 { "NullLog_swiginit", NullLog_swiginit, METH_VARARGS, NULL},
	 { "new_ScreenLog", _wrap_new_ScreenLog, METH_VARARGS, "\n"
		"ScreenLog(incoming, outgoing, event)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"incoming: bool\n"
		"outgoing: bool\n"
		"event: bool\n"
		"\n"
		"new_ScreenLog(sessionID, incoming, outgoing, event) -> ScreenLog\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"incoming: bool\n"
		"outgoing: bool\n"
		"event: bool\n"
		"\n"
		""},
	 { "ScreenLog_clear", _wrap_ScreenLog_clear, METH_O, "clear(self)"},
	 { "ScreenLog_backup", _wrap_ScreenLog_backup, METH_O, "backup(self)"},
	 { "ScreenLog_onIncoming", _wrap_ScreenLog_onIncoming, METH_VARARGS, "\n"
		"onIncoming(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "ScreenLog_onOutgoing", _wrap_ScreenLog_onOutgoing, METH_VARARGS, "\n"
		"onOutgoing(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "ScreenLog_onEvent", _wrap_ScreenLog_onEvent, METH_VARARGS, "\n"
		"onEvent(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "delete_ScreenLog", _wrap_delete_ScreenLog, METH_O, "delete_ScreenLog(self)"},
	 { "ScreenLog_swigregister", ScreenLog_swigregister, METH_O, NULL},
	 { "ScreenLog_swiginit", ScreenLog_swiginit, METH_VARARGS, NULL},
	 { "new_FileLogFactory", _wrap_new_FileLogFactory, METH_VARARGS, "\n"
		"FileLogFactory(settings)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"settings: FIX::SessionSettings const &\n"
		"\n"
		"FileLogFactory(path)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path: std::string const &\n"
		"\n"
		"new_FileLogFactory(path, backupPath) -> FileLogFactory\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path: std::string const &\n"
		"backupPath: std::string const &\n"
		"\n"
		""},
	 { "FileLogFactory_create", _wrap_FileLogFactory_create, METH_VARARGS, "\n"
		"create(self) -> Log\n"
		"create(self, arg2) -> Log\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		""},
	 { "FileLogFactory_destroy", _wrap_FileLogFactory_destroy, METH_VARARGS, "\n"
		"destroy(self, log)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"log: FIX::Log *\n"
		"\n"
		""},
	 { "delete_FileLogFactory", _wrap_delete_FileLogFactory, METH_O, "delete_FileLogFactory(self)"},
	 { "FileLogFactory_swigregister", FileLogFactory_swigregister, METH_O, NULL},
	 { "FileLogFactory_swiginit", FileLogFactory_swiginit, METH_VARARGS, NULL},
	 { "new_FileLog", _wrap_new_FileLog, METH_VARARGS, "\n"
		"FileLog(path)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path: std::string const &\n"
		"\n"
		"FileLog(path, backupPath)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path: std::string const &\n"
		"backupPath: std::string const &\n"
		"\n"
		"FileLog(path, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path: std::string const &\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		"new_FileLog(path, backupPath, sessionID) -> FileLog\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path: std::string const &\n"
		"backupPath: std::string const &\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "delete_FileLog", _wrap_delete_FileLog, METH_O, "delete_FileLog(self)"},
	 { "FileLog_clear", _wrap_FileLog_clear, METH_O, "clear(self)"},
	 { "FileLog_backup", _wrap_FileLog_backup, METH_O, "backup(self)"},
	 { "FileLog_onIncoming", _wrap_FileLog_onIncoming, METH_VARARGS, "\n"
		"onIncoming(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "FileLog_onOutgoing", _wrap_FileLog_onOutgoing, METH_VARARGS, "\n"
		"onOutgoing(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "FileLog_onEvent", _wrap_FileLog_onEvent, METH_VARARGS, "\n"
		"onEvent(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "FileLog_swigregister", FileLog_swigregister, METH_O, NULL},
	 { "FileLog_swiginit", FileLog_swiginit, METH_VARARGS, NULL},
	 { "delete_MessageStoreFactory", _wrap_delete_MessageStoreFactory, METH_O, "delete_MessageStoreFactory(self)"},
	 { "MessageStoreFactory_create", _wrap_MessageStoreFactory_create, METH_VARARGS, "\n"
		"create(self, now, arg3) -> MessageStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"arg3: FIX::SessionID const &\n"
		"\n"
		""},
	 { "MessageStoreFactory_destroy", _wrap_MessageStoreFactory_destroy, METH_VARARGS, "\n"
		"destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::MessageStore *\n"
		"\n"
		""},
	 { "MessageStoreFactory_swigregister", MessageStoreFactory_swigregister, METH_O, NULL},
	 { "MemoryStoreFactory_create", _wrap_MemoryStoreFactory_create, METH_VARARGS, "\n"
		"create(self, now, arg3) -> MessageStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"arg3: FIX::SessionID const &\n"
		"\n"
		""},
	 { "MemoryStoreFactory_destroy", _wrap_MemoryStoreFactory_destroy, METH_VARARGS, "\n"
		"destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::MessageStore *\n"
		"\n"
		""},
	 { "new_MemoryStoreFactory", _wrap_new_MemoryStoreFactory, METH_NOARGS, "new_MemoryStoreFactory() -> MemoryStoreFactory"},
	 { "delete_MemoryStoreFactory", _wrap_delete_MemoryStoreFactory, METH_O, "delete_MemoryStoreFactory(self)"},
	 { "MemoryStoreFactory_swigregister", MemoryStoreFactory_swigregister, METH_O, NULL},
	 { "MemoryStoreFactory_swiginit", MemoryStoreFactory_swiginit, METH_VARARGS, NULL},
	 { "delete_MessageStore", _wrap_delete_MessageStore, METH_O, "delete_MessageStore(self)"},
	 { "MessageStore_set", _wrap_MessageStore_set, METH_VARARGS, "\n"
		"set(self, arg2, arg3) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: std::string const &\n"
		"\n"
		""},
	 { "MessageStore_get", _wrap_MessageStore_get, METH_VARARGS, "\n"
		"get(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: FIX::SEQNUM\n"
		"arg4: std::vector< std::string,std::allocator< std::string > > &\n"
		"\n"
		""},
	 { "MessageStore_getNextSenderMsgSeqNum", _wrap_MessageStore_getNextSenderMsgSeqNum, METH_O, "getNextSenderMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "MessageStore_getNextTargetMsgSeqNum", _wrap_MessageStore_getNextTargetMsgSeqNum, METH_O, "getNextTargetMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "MessageStore_setNextSenderMsgSeqNum", _wrap_MessageStore_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"setNextSenderMsgSeqNum(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"\n"
		""},
	 { "MessageStore_setNextTargetMsgSeqNum", _wrap_MessageStore_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"setNextTargetMsgSeqNum(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"\n"
		""},
	 { "MessageStore_incrNextSenderMsgSeqNum", _wrap_MessageStore_incrNextSenderMsgSeqNum, METH_O, "incrNextSenderMsgSeqNum(self)"},
	 { "MessageStore_incrNextTargetMsgSeqNum", _wrap_MessageStore_incrNextTargetMsgSeqNum, METH_O, "incrNextTargetMsgSeqNum(self)"},
	 { "MessageStore_getCreationTime", _wrap_MessageStore_getCreationTime, METH_O, "getCreationTime(self) -> UtcTimeStamp"},
	 { "MessageStore_reset", _wrap_MessageStore_reset, METH_VARARGS, "\n"
		"reset(self, now)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "MessageStore_refresh", _wrap_MessageStore_refresh, METH_O, "refresh(self)"},
	 { "MessageStore_swigregister", MessageStore_swigregister, METH_O, NULL},
	 { "new_MemoryStore", _wrap_new_MemoryStore, METH_O, "\n"
		"new_MemoryStore(now) -> MemoryStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "MemoryStore_set", _wrap_MemoryStore_set, METH_VARARGS, "\n"
		"set(self, arg2, arg3) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: std::string const &\n"
		"\n"
		""},
	 { "MemoryStore_get", _wrap_MemoryStore_get, METH_VARARGS, "\n"
		"get(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: FIX::SEQNUM\n"
		"arg4: std::vector< std::string,std::allocator< std::string > > &\n"
		"\n"
		""},
	 { "MemoryStore_getNextSenderMsgSeqNum", _wrap_MemoryStore_getNextSenderMsgSeqNum, METH_O, "getNextSenderMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "MemoryStore_getNextTargetMsgSeqNum", _wrap_MemoryStore_getNextTargetMsgSeqNum, METH_O, "getNextTargetMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "MemoryStore_setNextSenderMsgSeqNum", _wrap_MemoryStore_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"setNextSenderMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "MemoryStore_setNextTargetMsgSeqNum", _wrap_MemoryStore_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"setNextTargetMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "MemoryStore_incrNextSenderMsgSeqNum", _wrap_MemoryStore_incrNextSenderMsgSeqNum, METH_O, "incrNextSenderMsgSeqNum(self)"},
	 { "MemoryStore_incrNextTargetMsgSeqNum", _wrap_MemoryStore_incrNextTargetMsgSeqNum, METH_O, "incrNextTargetMsgSeqNum(self)"},
	 { "MemoryStore_setCreationTime", _wrap_MemoryStore_setCreationTime, METH_VARARGS, "\n"
		"setCreationTime(self, creationTime)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"creationTime: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "MemoryStore_getCreationTime", _wrap_MemoryStore_getCreationTime, METH_O, "getCreationTime(self) -> UtcTimeStamp"},
	 { "MemoryStore_reset", _wrap_MemoryStore_reset, METH_VARARGS, "\n"
		"reset(self, now)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "MemoryStore_refresh", _wrap_MemoryStore_refresh, METH_O, "refresh(self)"},
	 { "delete_MemoryStore", _wrap_delete_MemoryStore, METH_O, "delete_MemoryStore(self)"},
	 { "MemoryStore_swigregister", MemoryStore_swigregister, METH_O, NULL},
	 { "MemoryStore_swiginit", MemoryStore_swiginit, METH_VARARGS, NULL},
	 { "new_MessageStoreFactoryExceptionWrapper", _wrap_new_MessageStoreFactoryExceptionWrapper, METH_O, "\n"
		"new_MessageStoreFactoryExceptionWrapper(pFactory) -> MessageStoreFactoryExceptionWrapper\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pFactory: FIX::MessageStoreFactory *\n"
		"\n"
		""},
	 { "MessageStoreFactoryExceptionWrapper_create", _wrap_MessageStoreFactoryExceptionWrapper_create, METH_VARARGS, "\n"
		"create(self, now, arg3, arg4, arg5) -> MessageStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"arg3: FIX::SessionID const &\n"
		"arg4: bool &\n"
		"arg5: FIX::ConfigError &\n"
		"\n"
		""},
	 { "MessageStoreFactoryExceptionWrapper_destroy", _wrap_MessageStoreFactoryExceptionWrapper_destroy, METH_VARARGS, "\n"
		"destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::MessageStore *\n"
		"\n"
		""},
	 { "delete_MessageStoreFactoryExceptionWrapper", _wrap_delete_MessageStoreFactoryExceptionWrapper, METH_O, "delete_MessageStoreFactoryExceptionWrapper(self)"},
	 { "MessageStoreFactoryExceptionWrapper_swigregister", MessageStoreFactoryExceptionWrapper_swigregister, METH_O, NULL},
	 { "MessageStoreFactoryExceptionWrapper_swiginit", MessageStoreFactoryExceptionWrapper_swiginit, METH_VARARGS, NULL},
	 { "new_MessageStoreExceptionWrapper", _wrap_new_MessageStoreExceptionWrapper, METH_O, "\n"
		"new_MessageStoreExceptionWrapper(pStore) -> MessageStoreExceptionWrapper\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pStore: FIX::MessageStore *\n"
		"\n"
		""},
	 { "delete_MessageStoreExceptionWrapper", _wrap_delete_MessageStoreExceptionWrapper, METH_O, "delete_MessageStoreExceptionWrapper(self)"},
	 { "MessageStoreExceptionWrapper_set", _wrap_MessageStoreExceptionWrapper_set, METH_VARARGS, "\n"
		"set(self, arg2, arg3, arg4, arg5) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: std::string const &\n"
		"arg4: bool &\n"
		"arg5: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_get", _wrap_MessageStoreExceptionWrapper_get, METH_VARARGS, "\n"
		"get(self, arg2, arg3, arg4, arg5, arg6)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: FIX::SEQNUM\n"
		"arg4: std::vector< std::string,std::allocator< std::string > > &\n"
		"arg5: bool &\n"
		"arg6: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_getNextSenderMsgSeqNum", _wrap_MessageStoreExceptionWrapper_getNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"getNextSenderMsgSeqNum(self, arg2, arg3) -> FIX::SEQNUM\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: bool &\n"
		"arg3: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_getNextTargetMsgSeqNum", _wrap_MessageStoreExceptionWrapper_getNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"getNextTargetMsgSeqNum(self, arg2, arg3) -> FIX::SEQNUM\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: bool &\n"
		"arg3: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_setNextSenderMsgSeqNum", _wrap_MessageStoreExceptionWrapper_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"setNextSenderMsgSeqNum(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: bool &\n"
		"arg4: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_setNextTargetMsgSeqNum", _wrap_MessageStoreExceptionWrapper_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"setNextTargetMsgSeqNum(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: bool &\n"
		"arg4: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum", _wrap_MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"incrNextSenderMsgSeqNum(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: bool &\n"
		"arg3: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum", _wrap_MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"incrNextTargetMsgSeqNum(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: bool &\n"
		"arg3: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_getCreationTime", _wrap_MessageStoreExceptionWrapper_getCreationTime, METH_VARARGS, "\n"
		"getCreationTime(self, arg2, arg3) -> UtcTimeStamp\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: bool &\n"
		"arg3: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_reset", _wrap_MessageStoreExceptionWrapper_reset, METH_VARARGS, "\n"
		"reset(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::UtcTimeStamp const &\n"
		"arg3: bool &\n"
		"arg4: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_refresh", _wrap_MessageStoreExceptionWrapper_refresh, METH_VARARGS, "\n"
		"refresh(self, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: bool &\n"
		"arg3: FIX::IOException &\n"
		"\n"
		""},
	 { "MessageStoreExceptionWrapper_swigregister", MessageStoreExceptionWrapper_swigregister, METH_O, NULL},
	 { "MessageStoreExceptionWrapper_swiginit", MessageStoreExceptionWrapper_swiginit, METH_VARARGS, NULL},
	 { "new_FileStoreFactory", _wrap_new_FileStoreFactory, METH_VARARGS, "\n"
		"FileStoreFactory(settings)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"settings: FIX::SessionSettings const &\n"
		"\n"
		"new_FileStoreFactory(path) -> FileStoreFactory\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path: std::string const &\n"
		"\n"
		""},
	 { "FileStoreFactory_create", _wrap_FileStoreFactory_create, METH_VARARGS, "\n"
		"create(self, arg2, arg3) -> MessageStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::UtcTimeStamp const &\n"
		"arg3: FIX::SessionID const &\n"
		"\n"
		""},
	 { "FileStoreFactory_destroy", _wrap_FileStoreFactory_destroy, METH_VARARGS, "\n"
		"destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::MessageStore *\n"
		"\n"
		""},
	 { "delete_FileStoreFactory", _wrap_delete_FileStoreFactory, METH_O, "delete_FileStoreFactory(self)"},
	 { "FileStoreFactory_swigregister", FileStoreFactory_swigregister, METH_O, NULL},
	 { "FileStoreFactory_swiginit", FileStoreFactory_swiginit, METH_VARARGS, NULL},
	 { "new_FileStore", _wrap_new_FileStore, METH_VARARGS, "\n"
		"new_FileStore(now, arg2, sessionID) -> FileStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"arg2: std::string\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "delete_FileStore", _wrap_delete_FileStore, METH_O, "delete_FileStore(self)"},
	 { "FileStore_set", _wrap_FileStore_set, METH_VARARGS, "\n"
		"set(self, arg2, arg3) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: std::string const &\n"
		"\n"
		""},
	 { "FileStore_get", _wrap_FileStore_get, METH_VARARGS, "\n"
		"get(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: FIX::SEQNUM\n"
		"arg4: std::vector< std::string,std::allocator< std::string > > &\n"
		"\n"
		""},
	 { "FileStore_getNextSenderMsgSeqNum", _wrap_FileStore_getNextSenderMsgSeqNum, METH_O, "getNextSenderMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "FileStore_getNextTargetMsgSeqNum", _wrap_FileStore_getNextTargetMsgSeqNum, METH_O, "getNextTargetMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "FileStore_setNextSenderMsgSeqNum", _wrap_FileStore_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"setNextSenderMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "FileStore_setNextTargetMsgSeqNum", _wrap_FileStore_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"setNextTargetMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "FileStore_incrNextSenderMsgSeqNum", _wrap_FileStore_incrNextSenderMsgSeqNum, METH_O, "incrNextSenderMsgSeqNum(self)"},
	 { "FileStore_incrNextTargetMsgSeqNum", _wrap_FileStore_incrNextTargetMsgSeqNum, METH_O, "incrNextTargetMsgSeqNum(self)"},
	 { "FileStore_getCreationTime", _wrap_FileStore_getCreationTime, METH_O, "getCreationTime(self) -> UtcTimeStamp"},
	 { "FileStore_reset", _wrap_FileStore_reset, METH_VARARGS, "\n"
		"reset(self, now)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "FileStore_refresh", _wrap_FileStore_refresh, METH_O, "refresh(self)"},
	 { "FileStore_swigregister", FileStore_swigregister, METH_O, NULL},
	 { "FileStore_swiginit", FileStore_swiginit, METH_VARARGS, NULL},
	 { "delete_Application", _wrap_delete_Application, METH_O, "delete_Application(self)"},
	 { "Application_onCreate", _wrap_Application_onCreate, METH_VARARGS, "\n"
		"onCreate(self, arg0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Application_onLogon", _wrap_Application_onLogon, METH_VARARGS, "\n"
		"onLogon(self, arg0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Application_onLogout", _wrap_Application_onLogout, METH_VARARGS, "\n"
		"onLogout(self, arg0)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Application_toAdmin", _wrap_Application_toAdmin, METH_VARARGS, "\n"
		"toAdmin(self, arg0, arg1)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::Message &\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Application_toApp", _wrap_Application_toApp, METH_VARARGS, "\n"
		"toApp(self, arg0, arg1)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::Message &\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Application_fromAdmin", _wrap_Application_fromAdmin, METH_VARARGS, "\n"
		"fromAdmin(self, arg0, arg1)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::Message const &\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Application_fromApp", _wrap_Application_fromApp, METH_VARARGS, "\n"
		"fromApp(self, arg0, arg1)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg0: FIX::Message const &\n"
		"arg1: FIX::SessionID const &\n"
		"\n"
		""},
	 { "new_Application", _wrap_new_Application, METH_O, "\n"
		"new_Application(_self) -> Application\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"self: PyObject *\n"
		"\n"
		""},
	 { "disown_Application", _wrap_disown_Application, METH_O, NULL},
	 { "Application_swigregister", Application_swigregister, METH_O, NULL},
	 { "Application_swiginit", Application_swiginit, METH_VARARGS, NULL},
	 { "new_SynchronizedApplication", _wrap_new_SynchronizedApplication, METH_O, "\n"
		"new_SynchronizedApplication(app) -> SynchronizedApplication\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"app: FIX::Application &\n"
		"\n"
		""},
	 { "SynchronizedApplication_onCreate", _wrap_SynchronizedApplication_onCreate, METH_VARARGS, "\n"
		"onCreate(self, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SynchronizedApplication_onLogon", _wrap_SynchronizedApplication_onLogon, METH_VARARGS, "\n"
		"onLogon(self, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SynchronizedApplication_onLogout", _wrap_SynchronizedApplication_onLogout, METH_VARARGS, "\n"
		"onLogout(self, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SynchronizedApplication_toAdmin", _wrap_SynchronizedApplication_toAdmin, METH_VARARGS, "\n"
		"toAdmin(self, message, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message &\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SynchronizedApplication_toApp", _wrap_SynchronizedApplication_toApp, METH_VARARGS, "\n"
		"toApp(self, message, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message &\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SynchronizedApplication_fromAdmin", _wrap_SynchronizedApplication_fromAdmin, METH_VARARGS, "\n"
		"fromAdmin(self, message, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message const &\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SynchronizedApplication_fromApp", _wrap_SynchronizedApplication_fromApp, METH_VARARGS, "\n"
		"fromApp(self, message, sessionID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message const &\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "SynchronizedApplication_m_mutex_set", _wrap_SynchronizedApplication_m_mutex_set, METH_VARARGS, "\n"
		"SynchronizedApplication_m_mutex_set(self, m_mutex)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"m_mutex: Mutex\n"
		"\n"
		""},
	 { "SynchronizedApplication_m_mutex_get", _wrap_SynchronizedApplication_m_mutex_get, METH_O, "SynchronizedApplication_m_mutex_get(self) -> Mutex"},
	 { "SynchronizedApplication_app", _wrap_SynchronizedApplication_app, METH_O, "app(self) -> Application"},
	 { "SynchronizedApplication_m_app_set", _wrap_SynchronizedApplication_m_app_set, METH_VARARGS, "\n"
		"SynchronizedApplication_m_app_set(self, m_app)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"m_app: FIX::Application &\n"
		"\n"
		""},
	 { "SynchronizedApplication_m_app_get", _wrap_SynchronizedApplication_m_app_get, METH_O, "SynchronizedApplication_m_app_get(self) -> Application"},
	 { "delete_SynchronizedApplication", _wrap_delete_SynchronizedApplication, METH_O, "delete_SynchronizedApplication(self)"},
	 { "SynchronizedApplication_swigregister", SynchronizedApplication_swigregister, METH_O, NULL},
	 { "SynchronizedApplication_swiginit", SynchronizedApplication_swiginit, METH_VARARGS, NULL},
	 { "new_NullApplication", _wrap_new_NullApplication, METH_NOARGS, "new_NullApplication() -> NullApplication"},
	 { "delete_NullApplication", _wrap_delete_NullApplication, METH_O, "delete_NullApplication(self)"},
	 { "NullApplication_swigregister", NullApplication_swigregister, METH_O, NULL},
	 { "NullApplication_swiginit", NullApplication_swiginit, METH_VARARGS, NULL},
	 { "delete_Initiator", _wrap_delete_Initiator, METH_O, "delete_Initiator(self)"},
	 { "Initiator_start", _wrap_Initiator_start, METH_O, "start(self)"},
	 { "Initiator_block", _wrap_Initiator_block, METH_O, "block(self)"},
	 { "Initiator_poll", _wrap_Initiator_poll, METH_O, "poll(self) -> bool"},
	 { "Initiator_stop", _wrap_Initiator_stop, METH_VARARGS, "\n"
		"stop(self, force=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"force: bool\n"
		"\n"
		""},
	 { "Initiator_isLoggedOn", _wrap_Initiator_isLoggedOn, METH_O, "isLoggedOn(self) -> bool"},
	 { "Initiator_getSessions", _wrap_Initiator_getSessions, METH_O, "getSessions(self) -> SessionIDSet"},
	 { "Initiator_getSession", _wrap_Initiator_getSession, METH_VARARGS, "\n"
		"getSession(self, sessionID, arg3) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"arg3: Responder &\n"
		"\n"
		"getSession(self, sessionID) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Initiator_getSessionSettings", _wrap_Initiator_getSessionSettings, METH_VARARGS, "\n"
		"getSessionSettings(self, sessionID) -> Dictionary\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Initiator_has", _wrap_Initiator_has, METH_VARARGS, "\n"
		"has(self, id) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Initiator_isStopped", _wrap_Initiator_isStopped, METH_O, "isStopped(self) -> bool"},
	 { "Initiator_getApplication", _wrap_Initiator_getApplication, METH_O, "getApplication(self) -> Application"},
	 { "Initiator_getMessageStoreFactory", _wrap_Initiator_getMessageStoreFactory, METH_O, "getMessageStoreFactory(self) -> MessageStoreFactory"},
	 { "Initiator_getLog", _wrap_Initiator_getLog, METH_O, "getLog(self) -> Log"},
	 { "Initiator_swigregister", Initiator_swigregister, METH_O, NULL},
	 { "new_SocketInitiatorBase", _wrap_new_SocketInitiatorBase, METH_VARARGS, "\n"
		"SocketInitiator(arg1, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"\n"
		"new_SocketInitiatorBase(arg1, arg2, arg3, arg4) -> SocketInitiatorBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"arg4: FIX::LogFactory &\n"
		"\n"
		""},
	 { "delete_SocketInitiatorBase", _wrap_delete_SocketInitiatorBase, METH_O, "delete_SocketInitiatorBase(self)"},
	 { "SocketInitiatorBase_swigregister", SocketInitiatorBase_swigregister, METH_O, NULL},
	 { "SocketInitiatorBase_swiginit", SocketInitiatorBase_swiginit, METH_VARARGS, NULL},
	 { "delete_Acceptor", _wrap_delete_Acceptor, METH_O, "delete_Acceptor(self)"},
	 { "Acceptor_getLog", _wrap_Acceptor_getLog, METH_O, "getLog(self) -> Log"},
	 { "Acceptor_start", _wrap_Acceptor_start, METH_O, "start(self)"},
	 { "Acceptor_block", _wrap_Acceptor_block, METH_O, "block(self)"},
	 { "Acceptor_poll", _wrap_Acceptor_poll, METH_O, "poll(self) -> bool"},
	 { "Acceptor_stop", _wrap_Acceptor_stop, METH_VARARGS, "\n"
		"stop(self, force=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"force: bool\n"
		"\n"
		""},
	 { "Acceptor_isLoggedOn", _wrap_Acceptor_isLoggedOn, METH_O, "isLoggedOn(self) -> bool"},
	 { "Acceptor_getSessions", _wrap_Acceptor_getSessions, METH_O, "getSessions(self) -> SessionIDSet"},
	 { "Acceptor_getSession", _wrap_Acceptor_getSession, METH_VARARGS, "\n"
		"getSession(self, msg, arg3) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msg: std::string const &\n"
		"arg3: Responder &\n"
		"\n"
		"getSession(self, sessionID) -> Session\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Acceptor_getSessionSettings", _wrap_Acceptor_getSessionSettings, METH_VARARGS, "\n"
		"getSessionSettings(self, sessionID) -> Dictionary\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Acceptor_has", _wrap_Acceptor_has, METH_VARARGS, "\n"
		"has(self, id) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id: FIX::SessionID const &\n"
		"\n"
		""},
	 { "Acceptor_isStopped", _wrap_Acceptor_isStopped, METH_O, "isStopped(self) -> bool"},
	 { "Acceptor_getApplication", _wrap_Acceptor_getApplication, METH_O, "getApplication(self) -> Application"},
	 { "Acceptor_getMessageStoreFactory", _wrap_Acceptor_getMessageStoreFactory, METH_O, "getMessageStoreFactory(self) -> MessageStoreFactory"},
	 { "Acceptor_swigregister", Acceptor_swigregister, METH_O, NULL},
	 { "new_SocketAcceptorBase", _wrap_new_SocketAcceptorBase, METH_VARARGS, "\n"
		"SocketAcceptor(arg1, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"\n"
		"new_SocketAcceptorBase(arg1, arg2, arg3, arg4) -> SocketAcceptorBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"arg4: FIX::LogFactory &\n"
		"\n"
		""},
	 { "delete_SocketAcceptorBase", _wrap_delete_SocketAcceptorBase, METH_O, "delete_SocketAcceptorBase(self)"},
	 { "SocketAcceptorBase_sessionToPort", _wrap_SocketAcceptorBase_sessionToPort, METH_O, "sessionToPort(self) -> FIX::SocketAcceptor::SessionToPort const &"},
	 { "SocketAcceptorBase_swigregister", SocketAcceptorBase_swigregister, METH_O, NULL},
	 { "SocketAcceptorBase_swiginit", SocketAcceptorBase_swiginit, METH_VARARGS, NULL},
	 { "new_DataDictionary", _wrap_new_DataDictionary, METH_VARARGS, "\n"
		"DataDictionary()\n"
		"DataDictionary(copy)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"copy: FIX::DataDictionary const &\n"
		"\n"
		"DataDictionary(stream, preserveMsgFldsOrder=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"stream: std::istream &\n"
		"preserveMsgFldsOrder: bool\n"
		"\n"
		"DataDictionary(url, preserveMsgFldsOrder=False)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"url: std::string const &\n"
		"preserveMsgFldsOrder: bool\n"
		"\n"
		""},
	 { "delete_DataDictionary", _wrap_delete_DataDictionary, METH_O, "delete_DataDictionary(self)"},
	 { "DataDictionary_readFromURL", _wrap_DataDictionary_readFromURL, METH_VARARGS, "\n"
		"readFromURL(self, url)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"url: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_readFromDocument", _wrap_DataDictionary_readFromDocument, METH_VARARGS, "\n"
		"readFromDocument(self, pDoc)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pDoc: DOMDocumentPtr const &\n"
		"\n"
		""},
	 { "DataDictionary_readFromStream", _wrap_DataDictionary_readFromStream, METH_VARARGS, "\n"
		"readFromStream(self, stream)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"stream: std::istream &\n"
		"\n"
		""},
	 { "DataDictionary_getOrderedFields", _wrap_DataDictionary_getOrderedFields, METH_O, "getOrderedFields(self) -> message_order const &"},
	 { "DataDictionary_getHeaderOrderedFields", _wrap_DataDictionary_getHeaderOrderedFields, METH_O, "getHeaderOrderedFields(self) -> message_order const &"},
	 { "DataDictionary_getTrailerOrderedFields", _wrap_DataDictionary_getTrailerOrderedFields, METH_O, "getTrailerOrderedFields(self) -> message_order const &"},
	 { "DataDictionary_getMessageOrderedFields", _wrap_DataDictionary_getMessageOrderedFields, METH_VARARGS, "\n"
		"getMessageOrderedFields(self, msgType) -> message_order const &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_setVersion", _wrap_DataDictionary_setVersion, METH_VARARGS, "\n"
		"setVersion(self, beginString)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"beginString: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_getVersion", _wrap_DataDictionary_getVersion, METH_O, "getVersion(self) -> std::string"},
	 { "DataDictionary_addField", _wrap_DataDictionary_addField, METH_VARARGS, "\n"
		"addField(self, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_addFieldName", _wrap_DataDictionary_addFieldName, METH_VARARGS, "\n"
		"addFieldName(self, field, name)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"name: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_getFieldName", _wrap_DataDictionary_getFieldName, METH_VARARGS, "\n"
		"getFieldName(self, field, name) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"name: std::string &\n"
		"\n"
		""},
	 { "DataDictionary_getFieldTag", _wrap_DataDictionary_getFieldTag, METH_VARARGS, "\n"
		"getFieldTag(self, name, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name: std::string const &\n"
		"field: int &\n"
		"\n"
		""},
	 { "DataDictionary_addValueName", _wrap_DataDictionary_addValueName, METH_VARARGS, "\n"
		"addValueName(self, field, value, name)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"value: std::string const &\n"
		"name: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_getValueName", _wrap_DataDictionary_getValueName, METH_VARARGS, "\n"
		"getValueName(self, field, value, name) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"value: std::string const &\n"
		"name: std::string &\n"
		"\n"
		""},
	 { "DataDictionary_getNameValue", _wrap_DataDictionary_getNameValue, METH_VARARGS, "\n"
		"getNameValue(self, field, name, value) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"name: std::string const &\n"
		"value: std::string &\n"
		"\n"
		""},
	 { "DataDictionary_isField", _wrap_DataDictionary_isField, METH_VARARGS, "\n"
		"isField(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_addMsgType", _wrap_DataDictionary_addMsgType, METH_VARARGS, "\n"
		"addMsgType(self, msgType)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_isMsgType", _wrap_DataDictionary_isMsgType, METH_VARARGS, "\n"
		"isMsgType(self, msgType) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_addMsgField", _wrap_DataDictionary_addMsgField, METH_VARARGS, "\n"
		"addMsgField(self, msgType, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: std::string const &\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_isMsgField", _wrap_DataDictionary_isMsgField, METH_VARARGS, "\n"
		"isMsgField(self, msgType, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: std::string const &\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_addHeaderField", _wrap_DataDictionary_addHeaderField, METH_VARARGS, "\n"
		"addHeaderField(self, field, required)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"required: bool\n"
		"\n"
		""},
	 { "DataDictionary_isHeaderField", _wrap_DataDictionary_isHeaderField, METH_VARARGS, "\n"
		"isHeaderField(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_addTrailerField", _wrap_DataDictionary_addTrailerField, METH_VARARGS, "\n"
		"addTrailerField(self, field, required)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"required: bool\n"
		"\n"
		""},
	 { "DataDictionary_isTrailerField", _wrap_DataDictionary_isTrailerField, METH_VARARGS, "\n"
		"isTrailerField(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_addFieldType", _wrap_DataDictionary_addFieldType, METH_VARARGS, "\n"
		"addFieldType(self, field, type)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"type: enum FIX::TYPE::Type\n"
		"\n"
		""},
	 { "DataDictionary_getFieldType", _wrap_DataDictionary_getFieldType, METH_VARARGS, "\n"
		"getFieldType(self, field, type) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"type: FIX::TYPE::Type &\n"
		"\n"
		""},
	 { "DataDictionary_addRequiredField", _wrap_DataDictionary_addRequiredField, METH_VARARGS, "\n"
		"addRequiredField(self, msgType, field)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: std::string const &\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_isRequiredField", _wrap_DataDictionary_isRequiredField, METH_VARARGS, "\n"
		"isRequiredField(self, msgType, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msgType: std::string const &\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_addFieldValue", _wrap_DataDictionary_addFieldValue, METH_VARARGS, "\n"
		"addFieldValue(self, field, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_hasFieldValue", _wrap_DataDictionary_hasFieldValue, METH_VARARGS, "\n"
		"hasFieldValue(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_isFieldValue", _wrap_DataDictionary_isFieldValue, METH_VARARGS, "\n"
		"isFieldValue(self, field, value) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "DataDictionary_addGroup", _wrap_DataDictionary_addGroup, METH_VARARGS, "\n"
		"addGroup(self, msg, field, delim, dataDictionary)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msg: std::string const &\n"
		"field: int\n"
		"delim: int\n"
		"dataDictionary: FIX::DataDictionary const &\n"
		"\n"
		""},
	 { "DataDictionary_isGroup", _wrap_DataDictionary_isGroup, METH_VARARGS, "\n"
		"isGroup(self, msg, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msg: std::string const &\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_getGroup", _wrap_DataDictionary_getGroup, METH_VARARGS, "\n"
		"getGroup(self, msg, field, delim, pDataDictionary) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"msg: std::string const &\n"
		"field: int\n"
		"delim: int &\n"
		"pDataDictionary: FIX::DataDictionary const *&\n"
		"\n"
		""},
	 { "DataDictionary_isDataField", _wrap_DataDictionary_isDataField, METH_VARARGS, "\n"
		"isDataField(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_isMultipleValueField", _wrap_DataDictionary_isMultipleValueField, METH_VARARGS, "\n"
		"isMultipleValueField(self, field) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"field: int\n"
		"\n"
		""},
	 { "DataDictionary_checkFieldsOutOfOrder", _wrap_DataDictionary_checkFieldsOutOfOrder, METH_VARARGS, "\n"
		"checkFieldsOutOfOrder(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "DataDictionary_checkFieldsHaveValues", _wrap_DataDictionary_checkFieldsHaveValues, METH_VARARGS, "\n"
		"checkFieldsHaveValues(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "DataDictionary_checkUserDefinedFields", _wrap_DataDictionary_checkUserDefinedFields, METH_VARARGS, "\n"
		"checkUserDefinedFields(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "DataDictionary_allowUnknownMsgFields", _wrap_DataDictionary_allowUnknownMsgFields, METH_VARARGS, "\n"
		"allowUnknownMsgFields(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "DataDictionary_preserveMessageFieldsOrder", _wrap_DataDictionary_preserveMessageFieldsOrder, METH_VARARGS, "\n"
		"preserveMessageFieldsOrder(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: bool\n"
		"\n"
		""},
	 { "DataDictionary_isMessageFieldsOrderPreserved", _wrap_DataDictionary_isMessageFieldsOrderPreserved, METH_O, "isMessageFieldsOrderPreserved(self) -> bool"},
	 { "DataDictionary_validate", _wrap_DataDictionary_validate, METH_VARARGS, "\n"
		"validate(self, message, pSessionDD, pAppID)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message const &\n"
		"pSessionDD: FIX::DataDictionary const *const\n"
		"pAppID: FIX::DataDictionary const *const\n"
		"\n"
		"validate(self, message)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message const &\n"
		"\n"
		"validate(self, message, bodyOnly)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"message: FIX::Message const &\n"
		"bodyOnly: bool\n"
		"\n"
		""},
	 { "DataDictionary_swigregister", DataDictionary_swigregister, METH_O, NULL},
	 { "DataDictionary_swiginit", DataDictionary_swiginit, METH_VARARGS, NULL},
	 { "new_SSLSocketAcceptorBase", _wrap_new_SSLSocketAcceptorBase, METH_VARARGS, "\n"
		"SSLSocketAcceptor(arg1, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"\n"
		"new_SSLSocketAcceptorBase(arg1, arg2, arg3, arg4) -> SSLSocketAcceptorBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"arg4: FIX::LogFactory &\n"
		"\n"
		""},
	 { "delete_SSLSocketAcceptorBase", _wrap_delete_SSLSocketAcceptorBase, METH_O, "delete_SSLSocketAcceptorBase(self)"},
	 { "SSLSocketAcceptorBase_setPassword", _wrap_SSLSocketAcceptorBase_setPassword, METH_VARARGS, "\n"
		"setPassword(self, pwd)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pwd: std::string const &\n"
		"\n"
		""},
	 { "SSLSocketAcceptorBase_passwordHandleCallback", _wrap_SSLSocketAcceptorBase_passwordHandleCallback, METH_VARARGS, "\n"
		"passwordHandleCallback(self, buf, bufsize, verify) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"buf: char *\n"
		"bufsize: size_t\n"
		"verify: int\n"
		"\n"
		""},
	 { "SSLSocketAcceptorBase_passPhraseHandleCB", _wrap_SSLSocketAcceptorBase_passPhraseHandleCB, METH_VARARGS, "\n"
		"passPhraseHandleCB(buf, bufsize, verify, instance) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"buf: char *\n"
		"bufsize: int\n"
		"verify: int\n"
		"instance: void *\n"
		"\n"
		""},
	 { "SSLSocketAcceptorBase_swigregister", SSLSocketAcceptorBase_swigregister, METH_O, NULL},
	 { "SSLSocketAcceptorBase_swiginit", SSLSocketAcceptorBase_swiginit, METH_VARARGS, NULL},
	 { "new_SSLSocketInitiatorBase", _wrap_new_SSLSocketInitiatorBase, METH_VARARGS, "\n"
		"SSLSocketInitiator(arg1, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"\n"
		"new_SSLSocketInitiatorBase(arg1, arg2, arg3, arg4) -> SSLSocketInitiatorBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"arg4: FIX::LogFactory &\n"
		"\n"
		""},
	 { "delete_SSLSocketInitiatorBase", _wrap_delete_SSLSocketInitiatorBase, METH_O, "delete_SSLSocketInitiatorBase(self)"},
	 { "SSLSocketInitiatorBase_setPassword", _wrap_SSLSocketInitiatorBase_setPassword, METH_VARARGS, "\n"
		"setPassword(self, pwd)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pwd: std::string const &\n"
		"\n"
		""},
	 { "SSLSocketInitiatorBase_setCertAndKey", _wrap_SSLSocketInitiatorBase_setCertAndKey, METH_VARARGS, "\n"
		"setCertAndKey(self, cert, key)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"cert: X509 *\n"
		"key: RSA *\n"
		"\n"
		""},
	 { "SSLSocketInitiatorBase_passwordHandleCallback", _wrap_SSLSocketInitiatorBase_passwordHandleCallback, METH_VARARGS, "\n"
		"passwordHandleCallback(self, buf, bufsize, verify) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"buf: char *\n"
		"bufsize: size_t\n"
		"verify: int\n"
		"\n"
		""},
	 { "SSLSocketInitiatorBase_passwordHandleCB", _wrap_SSLSocketInitiatorBase_passwordHandleCB, METH_VARARGS, "\n"
		"passwordHandleCB(buf, bufsize, verify, instance) -> int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"buf: char *\n"
		"bufsize: int\n"
		"verify: int\n"
		"instance: void *\n"
		"\n"
		""},
	 { "SSLSocketInitiatorBase_swigregister", SSLSocketInitiatorBase_swigregister, METH_O, NULL},
	 { "SSLSocketInitiatorBase_swiginit", SSLSocketInitiatorBase_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseConnectionID", _wrap_new_DatabaseConnectionID, METH_VARARGS, "\n"
		"new_DatabaseConnectionID(database, user, password, host, port) -> DatabaseConnectionID\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		""},
	 { "__lt__", _wrap___lt__, METH_VARARGS, "\n"
		"__lt__(lhs, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::DateTime const &\n"
		"rhs: FIX::DateTime const &\n"
		"\n"
		"__lt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: char const *\n"
		"\n"
		"__lt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: char const *\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__lt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: std::string const &\n"
		"\n"
		"__lt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::string const &\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__lt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		"__lt__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::DatabaseConnectionID const &\n"
		"arg2: FIX::DatabaseConnectionID const &\n"
		"\n"
		""},
	 { "__eq__", _wrap___eq__, METH_VARARGS, "\n"
		"__eq__(lhs, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::DateTime const &\n"
		"rhs: FIX::DateTime const &\n"
		"\n"
		"__eq__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: char const *\n"
		"\n"
		"__eq__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: char const *\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__eq__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: std::string const &\n"
		"\n"
		"__eq__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::string const &\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__eq__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		"__eq__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::DatabaseConnectionID const &\n"
		"arg2: FIX::DatabaseConnectionID const &\n"
		"\n"
		""},
	 { "__ne__", _wrap___ne__, METH_VARARGS, "\n"
		"__ne__(lhs, rhs) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"lhs: FIX::DateTime const &\n"
		"rhs: FIX::DateTime const &\n"
		"\n"
		"__ne__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: char const *\n"
		"\n"
		"__ne__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: char const *\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__ne__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::StringField const &\n"
		"arg2: std::string const &\n"
		"\n"
		"__ne__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: std::string const &\n"
		"arg2: FIX::StringField const &\n"
		"\n"
		"__ne__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::SessionID const &\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		"__ne__(arg1, arg2) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::DatabaseConnectionID const &\n"
		"arg2: FIX::DatabaseConnectionID const &\n"
		"\n"
		""},
	 { "DatabaseConnectionID_getDatabase", _wrap_DatabaseConnectionID_getDatabase, METH_O, "getDatabase(self) -> std::string const &"},
	 { "DatabaseConnectionID_getUser", _wrap_DatabaseConnectionID_getUser, METH_O, "getUser(self) -> std::string const &"},
	 { "DatabaseConnectionID_getPassword", _wrap_DatabaseConnectionID_getPassword, METH_O, "getPassword(self) -> std::string const &"},
	 { "DatabaseConnectionID_getHost", _wrap_DatabaseConnectionID_getHost, METH_O, "getHost(self) -> std::string const &"},
	 { "DatabaseConnectionID_getPort", _wrap_DatabaseConnectionID_getPort, METH_O, "getPort(self) -> short"},
	 { "delete_DatabaseConnectionID", _wrap_delete_DatabaseConnectionID, METH_O, "delete_DatabaseConnectionID(self)"},
	 { "DatabaseConnectionID_swigregister", DatabaseConnectionID_swigregister, METH_O, NULL},
	 { "DatabaseConnectionID_swiginit", DatabaseConnectionID_swiginit, METH_VARARGS, NULL},
	 { "new_MySQLQuery", _wrap_new_MySQLQuery, METH_O, "\n"
		"new_MySQLQuery(query) -> MySQLQuery\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"query: std::string const &\n"
		"\n"
		""},
	 { "delete_MySQLQuery", _wrap_delete_MySQLQuery, METH_O, "delete_MySQLQuery(self)"},
	 { "MySQLQuery_execute", _wrap_MySQLQuery_execute, METH_VARARGS, "\n"
		"execute(self, pConnection) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pConnection: MYSQL *\n"
		"\n"
		""},
	 { "MySQLQuery_success", _wrap_MySQLQuery_success, METH_O, "success(self) -> bool"},
	 { "MySQLQuery_rows", _wrap_MySQLQuery_rows, METH_O, "rows(self) -> int"},
	 { "MySQLQuery_reason", _wrap_MySQLQuery_reason, METH_O, "reason(self) -> std::string const &"},
	 { "MySQLQuery_getValue", _wrap_MySQLQuery_getValue, METH_VARARGS, "\n"
		"getValue(self, row, column) -> char *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"row: int\n"
		"column: int\n"
		"\n"
		""},
	 { "MySQLQuery_throwException", _wrap_MySQLQuery_throwException, METH_O, "throwException(self)"},
	 { "MySQLQuery_swigregister", MySQLQuery_swigregister, METH_O, NULL},
	 { "MySQLQuery_swiginit", MySQLQuery_swiginit, METH_VARARGS, NULL},
	 { "new_MySQLConnection", _wrap_new_MySQLConnection, METH_VARARGS, "\n"
		"MySQLConnection(id)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id: FIX::DatabaseConnectionID const &\n"
		"\n"
		"new_MySQLConnection(database, user, password, host, port) -> MySQLConnection\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		""},
	 { "delete_MySQLConnection", _wrap_delete_MySQLConnection, METH_O, "delete_MySQLConnection(self)"},
	 { "MySQLConnection_connectionID", _wrap_MySQLConnection_connectionID, METH_O, "connectionID(self) -> DatabaseConnectionID"},
	 { "MySQLConnection_connected", _wrap_MySQLConnection_connected, METH_O, "connected(self) -> bool"},
	 { "MySQLConnection_reconnect", _wrap_MySQLConnection_reconnect, METH_O, "reconnect(self) -> bool"},
	 { "MySQLConnection_execute", _wrap_MySQLConnection_execute, METH_VARARGS, "\n"
		"execute(self, pQuery) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pQuery: FIX::MySQLQuery &\n"
		"\n"
		""},
	 { "MySQLConnection_swigregister", MySQLConnection_swigregister, METH_O, NULL},
	 { "MySQLConnection_swiginit", MySQLConnection_swiginit, METH_VARARGS, NULL},
	 { "new_MySQLStoreFactory", _wrap_new_MySQLStoreFactory, METH_VARARGS, "\n"
		"MySQLStoreFactory(settings)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"settings: FIX::SessionSettings const &\n"
		"\n"
		"MySQLStoreFactory(dictionary)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dictionary: FIX::Dictionary const &\n"
		"\n"
		"MySQLStoreFactory(database, user, password, host, port)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		"new_MySQLStoreFactory() -> MySQLStoreFactory\n"
		""},
	 { "MySQLStoreFactory_create", _wrap_MySQLStoreFactory_create, METH_VARARGS, "\n"
		"create(self, arg2, arg3) -> MessageStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::UtcTimeStamp const &\n"
		"arg3: FIX::SessionID const &\n"
		"\n"
		""},
	 { "MySQLStoreFactory_destroy", _wrap_MySQLStoreFactory_destroy, METH_VARARGS, "\n"
		"destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::MessageStore *\n"
		"\n"
		""},
	 { "delete_MySQLStoreFactory", _wrap_delete_MySQLStoreFactory, METH_O, "delete_MySQLStoreFactory(self)"},
	 { "MySQLStoreFactory_swigregister", MySQLStoreFactory_swigregister, METH_O, NULL},
	 { "MySQLStoreFactory_swiginit", MySQLStoreFactory_swiginit, METH_VARARGS, NULL},
	 { "new_MySQLStore", _wrap_new_MySQLStore, METH_VARARGS, "\n"
		"MySQLStore(now, sessionID, connection, pool)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"sessionID: FIX::SessionID const &\n"
		"connection: FIX::DatabaseConnectionID const &\n"
		"pool: FIX::MySQLConnectionPool *\n"
		"\n"
		"new_MySQLStore(now, sessionID, database, user, password, host, port) -> MySQLStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"sessionID: FIX::SessionID const &\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		""},
	 { "delete_MySQLStore", _wrap_delete_MySQLStore, METH_O, "delete_MySQLStore(self)"},
	 { "MySQLStore_set", _wrap_MySQLStore_set, METH_VARARGS, "\n"
		"set(self, arg2, arg3) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: std::string const &\n"
		"\n"
		""},
	 { "MySQLStore_get", _wrap_MySQLStore_get, METH_VARARGS, "\n"
		"get(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: FIX::SEQNUM\n"
		"arg4: std::vector< std::string,std::allocator< std::string > > &\n"
		"\n"
		""},
	 { "MySQLStore_getNextSenderMsgSeqNum", _wrap_MySQLStore_getNextSenderMsgSeqNum, METH_O, "getNextSenderMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "MySQLStore_getNextTargetMsgSeqNum", _wrap_MySQLStore_getNextTargetMsgSeqNum, METH_O, "getNextTargetMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "MySQLStore_setNextSenderMsgSeqNum", _wrap_MySQLStore_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"setNextSenderMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "MySQLStore_setNextTargetMsgSeqNum", _wrap_MySQLStore_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"setNextTargetMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "MySQLStore_incrNextSenderMsgSeqNum", _wrap_MySQLStore_incrNextSenderMsgSeqNum, METH_O, "incrNextSenderMsgSeqNum(self)"},
	 { "MySQLStore_incrNextTargetMsgSeqNum", _wrap_MySQLStore_incrNextTargetMsgSeqNum, METH_O, "incrNextTargetMsgSeqNum(self)"},
	 { "MySQLStore_getCreationTime", _wrap_MySQLStore_getCreationTime, METH_O, "getCreationTime(self) -> UtcTimeStamp"},
	 { "MySQLStore_reset", _wrap_MySQLStore_reset, METH_VARARGS, "\n"
		"reset(self, now)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "MySQLStore_refresh", _wrap_MySQLStore_refresh, METH_O, "refresh(self)"},
	 { "MySQLStore_swigregister", MySQLStore_swigregister, METH_O, NULL},
	 { "MySQLStore_swiginit", MySQLStore_swiginit, METH_VARARGS, NULL},
	 { "new_MySQLLog", _wrap_new_MySQLLog, METH_VARARGS, "\n"
		"MySQLLog(sessionID, connectionID, pool)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"connectionID: FIX::DatabaseConnectionID const &\n"
		"pool: FIX::MySQLConnectionPool *\n"
		"\n"
		"MySQLLog(connectionID, pool)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"connectionID: FIX::DatabaseConnectionID const &\n"
		"pool: FIX::MySQLConnectionPool *\n"
		"\n"
		"MySQLLog(sessionID, database, user, password, host, port)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sessionID: FIX::SessionID const &\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		"new_MySQLLog(database, user, password, host, port) -> MySQLLog\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		""},
	 { "delete_MySQLLog", _wrap_delete_MySQLLog, METH_O, "delete_MySQLLog(self)"},
	 { "MySQLLog_clear", _wrap_MySQLLog_clear, METH_O, "clear(self)"},
	 { "MySQLLog_backup", _wrap_MySQLLog_backup, METH_O, "backup(self)"},
	 { "MySQLLog_setIncomingTable", _wrap_MySQLLog_setIncomingTable, METH_VARARGS, "\n"
		"setIncomingTable(self, incomingTable)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"incomingTable: std::string const &\n"
		"\n"
		""},
	 { "MySQLLog_setOutgoingTable", _wrap_MySQLLog_setOutgoingTable, METH_VARARGS, "\n"
		"setOutgoingTable(self, outgoingTable)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"outgoingTable: std::string const &\n"
		"\n"
		""},
	 { "MySQLLog_setEventTable", _wrap_MySQLLog_setEventTable, METH_VARARGS, "\n"
		"setEventTable(self, eventTable)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eventTable: std::string const &\n"
		"\n"
		""},
	 { "MySQLLog_onIncoming", _wrap_MySQLLog_onIncoming, METH_VARARGS, "\n"
		"onIncoming(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "MySQLLog_onOutgoing", _wrap_MySQLLog_onOutgoing, METH_VARARGS, "\n"
		"onOutgoing(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "MySQLLog_onEvent", _wrap_MySQLLog_onEvent, METH_VARARGS, "\n"
		"onEvent(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "MySQLLog_swigregister", MySQLLog_swigregister, METH_O, NULL},
	 { "MySQLLog_swiginit", MySQLLog_swiginit, METH_VARARGS, NULL},
	 { "new_MySQLLogFactory", _wrap_new_MySQLLogFactory, METH_VARARGS, "\n"
		"MySQLLogFactory(settings)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"settings: FIX::SessionSettings const &\n"
		"\n"
		"MySQLLogFactory(database, user, password, host, port)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		"new_MySQLLogFactory() -> MySQLLogFactory\n"
		""},
	 { "MySQLLogFactory_create", _wrap_MySQLLogFactory_create, METH_VARARGS, "\n"
		"create(self) -> Log\n"
		"create(self, arg2) -> Log\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		""},
	 { "MySQLLogFactory_destroy", _wrap_MySQLLogFactory_destroy, METH_VARARGS, "\n"
		"destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::Log *\n"
		"\n"
		""},
	 { "delete_MySQLLogFactory", _wrap_delete_MySQLLogFactory, METH_O, "delete_MySQLLogFactory(self)"},
	 { "MySQLLogFactory_swigregister", MySQLLogFactory_swigregister, METH_O, NULL},
	 { "MySQLLogFactory_swiginit", MySQLLogFactory_swiginit, METH_VARARGS, NULL},
	 { "new_PostgreSQLQuery", _wrap_new_PostgreSQLQuery, METH_O, "\n"
		"new_PostgreSQLQuery(query) -> PostgreSQLQuery\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"query: std::string const &\n"
		"\n"
		""},
	 { "delete_PostgreSQLQuery", _wrap_delete_PostgreSQLQuery, METH_O, "delete_PostgreSQLQuery(self)"},
	 { "PostgreSQLQuery_execute", _wrap_PostgreSQLQuery_execute, METH_VARARGS, "\n"
		"execute(self, pConnection) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pConnection: PGconn *\n"
		"\n"
		""},
	 { "PostgreSQLQuery_success", _wrap_PostgreSQLQuery_success, METH_O, "success(self) -> bool"},
	 { "PostgreSQLQuery_rows", _wrap_PostgreSQLQuery_rows, METH_O, "rows(self) -> int"},
	 { "PostgreSQLQuery_reason", _wrap_PostgreSQLQuery_reason, METH_O, "reason(self) -> char *"},
	 { "PostgreSQLQuery_getValue", _wrap_PostgreSQLQuery_getValue, METH_VARARGS, "\n"
		"getValue(self, row, column) -> char *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"row: int\n"
		"column: int\n"
		"\n"
		""},
	 { "PostgreSQLQuery_throwException", _wrap_PostgreSQLQuery_throwException, METH_O, "throwException(self)"},
	 { "PostgreSQLQuery_swigregister", PostgreSQLQuery_swigregister, METH_O, NULL},
	 { "PostgreSQLQuery_swiginit", PostgreSQLQuery_swiginit, METH_VARARGS, NULL},
	 { "new_PostgreSQLConnection", _wrap_new_PostgreSQLConnection, METH_VARARGS, "\n"
		"PostgreSQLConnection(id)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id: FIX::DatabaseConnectionID const &\n"
		"\n"
		"new_PostgreSQLConnection(database, user, password, host, port) -> PostgreSQLConnection\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		""},
	 { "delete_PostgreSQLConnection", _wrap_delete_PostgreSQLConnection, METH_O, "delete_PostgreSQLConnection(self)"},
	 { "PostgreSQLConnection_connectionID", _wrap_PostgreSQLConnection_connectionID, METH_O, "connectionID(self) -> DatabaseConnectionID"},
	 { "PostgreSQLConnection_connected", _wrap_PostgreSQLConnection_connected, METH_O, "connected(self) -> bool"},
	 { "PostgreSQLConnection_reconnect", _wrap_PostgreSQLConnection_reconnect, METH_O, "reconnect(self) -> bool"},
	 { "PostgreSQLConnection_execute", _wrap_PostgreSQLConnection_execute, METH_VARARGS, "\n"
		"execute(self, pQuery) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pQuery: FIX::PostgreSQLQuery &\n"
		"\n"
		""},
	 { "PostgreSQLConnection_swigregister", PostgreSQLConnection_swigregister, METH_O, NULL},
	 { "PostgreSQLConnection_swiginit", PostgreSQLConnection_swiginit, METH_VARARGS, NULL},
	 { "new_PostgreSQLStoreFactory", _wrap_new_PostgreSQLStoreFactory, METH_VARARGS, "\n"
		"PostgreSQLStoreFactory(settings)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"settings: FIX::SessionSettings const &\n"
		"\n"
		"PostgreSQLStoreFactory(dictionary)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dictionary: FIX::Dictionary const &\n"
		"\n"
		"PostgreSQLStoreFactory(database, user, password, host, port)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		"new_PostgreSQLStoreFactory() -> PostgreSQLStoreFactory\n"
		""},
	 { "PostgreSQLStoreFactory_create", _wrap_PostgreSQLStoreFactory_create, METH_VARARGS, "\n"
		"create(self, arg2, arg3) -> MessageStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::UtcTimeStamp const &\n"
		"arg3: FIX::SessionID const &\n"
		"\n"
		""},
	 { "PostgreSQLStoreFactory_destroy", _wrap_PostgreSQLStoreFactory_destroy, METH_VARARGS, "\n"
		"destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::MessageStore *\n"
		"\n"
		""},
	 { "delete_PostgreSQLStoreFactory", _wrap_delete_PostgreSQLStoreFactory, METH_O, "delete_PostgreSQLStoreFactory(self)"},
	 { "PostgreSQLStoreFactory_swigregister", PostgreSQLStoreFactory_swigregister, METH_O, NULL},
	 { "PostgreSQLStoreFactory_swiginit", PostgreSQLStoreFactory_swiginit, METH_VARARGS, NULL},
	 { "new_PostgreSQLStore", _wrap_new_PostgreSQLStore, METH_VARARGS, "\n"
		"PostgreSQLStore(now, sessionID, connection, pool)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"sessionID: FIX::SessionID const &\n"
		"connection: FIX::DatabaseConnectionID const &\n"
		"pool: FIX::PostgreSQLConnectionPool *\n"
		"\n"
		"new_PostgreSQLStore(now, sessionID, database, user, password, host, port) -> PostgreSQLStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"sessionID: FIX::SessionID const &\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		""},
	 { "delete_PostgreSQLStore", _wrap_delete_PostgreSQLStore, METH_O, "delete_PostgreSQLStore(self)"},
	 { "PostgreSQLStore_set", _wrap_PostgreSQLStore_set, METH_VARARGS, "\n"
		"set(self, arg2, arg3) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: std::string const &\n"
		"\n"
		""},
	 { "PostgreSQLStore_get", _wrap_PostgreSQLStore_get, METH_VARARGS, "\n"
		"get(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: FIX::SEQNUM\n"
		"arg4: std::vector< std::string,std::allocator< std::string > > &\n"
		"\n"
		""},
	 { "PostgreSQLStore_getNextSenderMsgSeqNum", _wrap_PostgreSQLStore_getNextSenderMsgSeqNum, METH_O, "getNextSenderMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "PostgreSQLStore_getNextTargetMsgSeqNum", _wrap_PostgreSQLStore_getNextTargetMsgSeqNum, METH_O, "getNextTargetMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "PostgreSQLStore_setNextSenderMsgSeqNum", _wrap_PostgreSQLStore_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"setNextSenderMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "PostgreSQLStore_setNextTargetMsgSeqNum", _wrap_PostgreSQLStore_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"setNextTargetMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "PostgreSQLStore_incrNextSenderMsgSeqNum", _wrap_PostgreSQLStore_incrNextSenderMsgSeqNum, METH_O, "incrNextSenderMsgSeqNum(self)"},
	 { "PostgreSQLStore_incrNextTargetMsgSeqNum", _wrap_PostgreSQLStore_incrNextTargetMsgSeqNum, METH_O, "incrNextTargetMsgSeqNum(self)"},
	 { "PostgreSQLStore_getCreationTime", _wrap_PostgreSQLStore_getCreationTime, METH_O, "getCreationTime(self) -> UtcTimeStamp"},
	 { "PostgreSQLStore_reset", _wrap_PostgreSQLStore_reset, METH_VARARGS, "\n"
		"reset(self, now)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "PostgreSQLStore_refresh", _wrap_PostgreSQLStore_refresh, METH_O, "refresh(self)"},
	 { "PostgreSQLStore_swigregister", PostgreSQLStore_swigregister, METH_O, NULL},
	 { "PostgreSQLStore_swiginit", PostgreSQLStore_swiginit, METH_VARARGS, NULL},
	 { "new_PostgreSQLLog", _wrap_new_PostgreSQLLog, METH_VARARGS, "\n"
		"PostgreSQLLog(s, d, p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"s: FIX::SessionID const &\n"
		"d: FIX::DatabaseConnectionID const &\n"
		"p: FIX::PostgreSQLConnectionPool *\n"
		"\n"
		"PostgreSQLLog(d, p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"d: FIX::DatabaseConnectionID const &\n"
		"p: FIX::PostgreSQLConnectionPool *\n"
		"\n"
		"PostgreSQLLog(s, database, user, password, host, port)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"s: FIX::SessionID const &\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		"new_PostgreSQLLog(database, user, password, host, port) -> PostgreSQLLog\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		""},
	 { "delete_PostgreSQLLog", _wrap_delete_PostgreSQLLog, METH_O, "delete_PostgreSQLLog(self)"},
	 { "PostgreSQLLog_clear", _wrap_PostgreSQLLog_clear, METH_O, "clear(self)"},
	 { "PostgreSQLLog_backup", _wrap_PostgreSQLLog_backup, METH_O, "backup(self)"},
	 { "PostgreSQLLog_setIncomingTable", _wrap_PostgreSQLLog_setIncomingTable, METH_VARARGS, "\n"
		"setIncomingTable(self, incomingTable)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"incomingTable: std::string const &\n"
		"\n"
		""},
	 { "PostgreSQLLog_setOutgoingTable", _wrap_PostgreSQLLog_setOutgoingTable, METH_VARARGS, "\n"
		"setOutgoingTable(self, outgoingTable)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"outgoingTable: std::string const &\n"
		"\n"
		""},
	 { "PostgreSQLLog_setEventTable", _wrap_PostgreSQLLog_setEventTable, METH_VARARGS, "\n"
		"setEventTable(self, eventTable)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eventTable: std::string const &\n"
		"\n"
		""},
	 { "PostgreSQLLog_onIncoming", _wrap_PostgreSQLLog_onIncoming, METH_VARARGS, "\n"
		"onIncoming(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "PostgreSQLLog_onOutgoing", _wrap_PostgreSQLLog_onOutgoing, METH_VARARGS, "\n"
		"onOutgoing(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "PostgreSQLLog_onEvent", _wrap_PostgreSQLLog_onEvent, METH_VARARGS, "\n"
		"onEvent(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: std::string const &\n"
		"\n"
		""},
	 { "PostgreSQLLog_swigregister", PostgreSQLLog_swigregister, METH_O, NULL},
	 { "PostgreSQLLog_swiginit", PostgreSQLLog_swiginit, METH_VARARGS, NULL},
	 { "new_PostgreSQLLogFactory", _wrap_new_PostgreSQLLogFactory, METH_VARARGS, "\n"
		"PostgreSQLLogFactory(settings)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"settings: FIX::SessionSettings const &\n"
		"\n"
		"PostgreSQLLogFactory(database, user, password, host, port)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"database: std::string const &\n"
		"user: std::string const &\n"
		"password: std::string const &\n"
		"host: std::string const &\n"
		"port: short\n"
		"\n"
		"new_PostgreSQLLogFactory() -> PostgreSQLLogFactory\n"
		""},
	 { "PostgreSQLLogFactory_create", _wrap_PostgreSQLLogFactory_create, METH_VARARGS, "\n"
		"create(self) -> Log\n"
		"create(self, arg2) -> Log\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SessionID const &\n"
		"\n"
		""},
	 { "PostgreSQLLogFactory_destroy", _wrap_PostgreSQLLogFactory_destroy, METH_VARARGS, "\n"
		"destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::Log *\n"
		"\n"
		""},
	 { "delete_PostgreSQLLogFactory", _wrap_delete_PostgreSQLLogFactory, METH_O, "delete_PostgreSQLLogFactory(self)"},
	 { "PostgreSQLLogFactory_swigregister", PostgreSQLLogFactory_swigregister, METH_O, NULL},
	 { "PostgreSQLLogFactory_swiginit", PostgreSQLLogFactory_swiginit, METH_VARARGS, NULL},
	 { "new_ThreadedSocketAcceptorBase", _wrap_new_ThreadedSocketAcceptorBase, METH_VARARGS, "\n"
		"ThreadedSocketAcceptor(arg1, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"\n"
		"new_ThreadedSocketAcceptorBase(arg1, arg2, arg3, arg4) -> ThreadedSocketAcceptorBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"arg4: FIX::LogFactory &\n"
		"\n"
		""},
	 { "delete_ThreadedSocketAcceptorBase", _wrap_delete_ThreadedSocketAcceptorBase, METH_O, "delete_ThreadedSocketAcceptorBase(self)"},
	 { "ThreadedSocketAcceptorBase_swigregister", ThreadedSocketAcceptorBase_swigregister, METH_O, NULL},
	 { "ThreadedSocketAcceptorBase_swiginit", ThreadedSocketAcceptorBase_swiginit, METH_VARARGS, NULL},
	 { "new_ThreadedSocketInitiatorBase", _wrap_new_ThreadedSocketInitiatorBase, METH_VARARGS, "\n"
		"ThreadedSocketInitiator(arg1, arg2, arg3)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"\n"
		"new_ThreadedSocketInitiatorBase(arg1, arg2, arg3, arg4) -> ThreadedSocketInitiatorBase\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg1: FIX::Application &\n"
		"arg2: FIX::MessageStoreFactory &\n"
		"arg3: FIX::SessionSettings const &\n"
		"arg4: FIX::LogFactory &\n"
		"\n"
		""},
	 { "delete_ThreadedSocketInitiatorBase", _wrap_delete_ThreadedSocketInitiatorBase, METH_O, "delete_ThreadedSocketInitiatorBase(self)"},
	 { "ThreadedSocketInitiatorBase_swigregister", ThreadedSocketInitiatorBase_swigregister, METH_O, NULL},
	 { "ThreadedSocketInitiatorBase_swiginit", ThreadedSocketInitiatorBase_swiginit, METH_VARARGS, NULL},
	 { "NullStoreFactory_create", _wrap_NullStoreFactory_create, METH_VARARGS, "\n"
		"create(self, arg2, arg3) -> MessageStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::UtcTimeStamp const &\n"
		"arg3: FIX::SessionID const &\n"
		"\n"
		""},
	 { "NullStoreFactory_destroy", _wrap_NullStoreFactory_destroy, METH_VARARGS, "\n"
		"destroy(self, arg2)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::MessageStore *\n"
		"\n"
		""},
	 { "new_NullStoreFactory", _wrap_new_NullStoreFactory, METH_NOARGS, "new_NullStoreFactory() -> NullStoreFactory"},
	 { "delete_NullStoreFactory", _wrap_delete_NullStoreFactory, METH_O, "delete_NullStoreFactory(self)"},
	 { "NullStoreFactory_swigregister", NullStoreFactory_swigregister, METH_O, NULL},
	 { "NullStoreFactory_swiginit", NullStoreFactory_swiginit, METH_VARARGS, NULL},
	 { "new_NullStore", _wrap_new_NullStore, METH_O, "\n"
		"new_NullStore(now) -> NullStore\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "NullStore_set", _wrap_NullStore_set, METH_VARARGS, "\n"
		"set(self, arg2, arg3) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: std::string const &\n"
		"\n"
		""},
	 { "NullStore_get", _wrap_NullStore_get, METH_VARARGS, "\n"
		"get(self, arg2, arg3, arg4)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2: FIX::SEQNUM\n"
		"arg3: FIX::SEQNUM\n"
		"arg4: std::vector< std::string,std::allocator< std::string > > &\n"
		"\n"
		""},
	 { "NullStore_getNextSenderMsgSeqNum", _wrap_NullStore_getNextSenderMsgSeqNum, METH_O, "getNextSenderMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "NullStore_getNextTargetMsgSeqNum", _wrap_NullStore_getNextTargetMsgSeqNum, METH_O, "getNextTargetMsgSeqNum(self) -> FIX::SEQNUM"},
	 { "NullStore_setNextSenderMsgSeqNum", _wrap_NullStore_setNextSenderMsgSeqNum, METH_VARARGS, "\n"
		"setNextSenderMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "NullStore_setNextTargetMsgSeqNum", _wrap_NullStore_setNextTargetMsgSeqNum, METH_VARARGS, "\n"
		"setNextTargetMsgSeqNum(self, value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value: FIX::SEQNUM\n"
		"\n"
		""},
	 { "NullStore_incrNextSenderMsgSeqNum", _wrap_NullStore_incrNextSenderMsgSeqNum, METH_O, "incrNextSenderMsgSeqNum(self)"},
	 { "NullStore_incrNextTargetMsgSeqNum", _wrap_NullStore_incrNextTargetMsgSeqNum, METH_O, "incrNextTargetMsgSeqNum(self)"},
	 { "NullStore_setCreationTime", _wrap_NullStore_setCreationTime, METH_VARARGS, "\n"
		"setCreationTime(self, creationTime)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"creationTime: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "NullStore_getCreationTime", _wrap_NullStore_getCreationTime, METH_O, "getCreationTime(self) -> UtcTimeStamp"},
	 { "NullStore_reset", _wrap_NullStore_reset, METH_VARARGS, "\n"
		"reset(self, now)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"now: FIX::UtcTimeStamp const &\n"
		"\n"
		""},
	 { "NullStore_refresh", _wrap_NullStore_refresh, METH_O, "refresh(self)"},
	 { "delete_NullStore", _wrap_delete_NullStore, METH_O, "delete_NullStore(self)"},
	 { "NullStore_swigregister", NullStore_swigregister, METH_O, NULL},
	 { "NullStore_swiginit", NullStore_swiginit, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_IntArrayTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int *)  ((IntArray *) x));
}
static void *_p_FIX__SSLSocketAcceptorTo_p_FIX__Acceptor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Acceptor *)  ((FIX::SSLSocketAcceptor *) x));
}
static void *_p_FIX__SocketAcceptorTo_p_FIX__Acceptor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Acceptor *)  ((FIX::SocketAcceptor *) x));
}
static void *_p_FIX__ThreadedSocketAcceptorTo_p_FIX__Acceptor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Acceptor *)  ((FIX::ThreadedSocketAcceptor *) x));
}
static void *_p_FIX__NullApplicationTo_p_FIX__Application(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Application *)  ((FIX::NullApplication *) x));
}
static void *_p_FIX__SynchronizedApplicationTo_p_FIX__Application(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Application *)  ((FIX::SynchronizedApplication *) x));
}
static void *_p_FIX__LocalDateTo_p_FIX__DateTime(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DateTime *)  ((FIX::LocalDate *) x));
}
static void *_p_FIX__LocalTimeOnlyTo_p_FIX__DateTime(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DateTime *)  ((FIX::LocalTimeOnly *) x));
}
static void *_p_FIX__LocalTimeStampTo_p_FIX__DateTime(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DateTime *)  ((FIX::LocalTimeStamp *) x));
}
static void *_p_FIX__UtcDateTo_p_FIX__DateTime(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DateTime *)  ((FIX::UtcDate *) x));
}
static void *_p_FIX__UtcTimeOnlyTo_p_FIX__DateTime(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DateTime *)  ((FIX::UtcTimeOnly *) x));
}
static void *_p_FIX__UtcTimeStampTo_p_FIX__DateTime(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DateTime *)  ((FIX::UtcTimeStamp *) x));
}
static void *_p_FIX__ConfigErrorTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::ConfigError *) x));
}
static void *_p_FIX__DataDictionaryNotFoundTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::DataDictionaryNotFound *) x));
}
static void *_p_FIX__DoNotSendTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::DoNotSend *) x));
}
static void *_p_FIX__DuplicateFieldNumberTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::DuplicateFieldNumber *) x));
}
static void *_p_FIX__FieldConvertErrorTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::FieldConvertError *) x));
}
static void *_p_FIX__FieldNotFoundTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::FieldNotFound *) x));
}
static void *_p_FIX__IOExceptionTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::IOException *) x));
}
static void *_p_FIX__IncorrectDataFormatTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectDataFormat *) x));
}
static void *_p_FIX__IncorrectMessageStructureTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectMessageStructure *) x));
}
static void *_p_FIX__IncorrectTagValueTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectTagValue *) x));
}
static void *_p_FIX__InvalidMessageTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidMessage *) x));
}
static void *_p_FIX__InvalidMessageTypeTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidMessageType *) x));
}
static void *_p_FIX__InvalidTagNumberTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidTagNumber *) x));
}
static void *_p_FIX__MessageParseErrorTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::MessageParseError *) x));
}
static void *_p_FIX__NoTagValueTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::NoTagValue *) x));
}
static void *_p_FIX__RejectLogonTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RejectLogon *) x));
}
static void *_p_FIX__RepeatedTagTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RepeatedTag *) x));
}
static void *_p_FIX__RepeatingGroupCountMismatchTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RepeatingGroupCountMismatch *) x));
}
static void *_p_FIX__RequiredTagMissingTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RequiredTagMissing *) x));
}
static void *_p_FIX__RuntimeErrorTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RuntimeError *) x));
}
static void *_p_FIX__SessionNotFoundTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::SessionNotFound *) x));
}
static void *_p_FIX__SocketCloseFailedTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketCloseFailed *) x));
}
static void *_p_FIX__SocketExceptionTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::SocketException *) x));
}
static void *_p_FIX__SocketRecvFailedTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketRecvFailed *) x));
}
static void *_p_FIX__SocketSendFailedTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketSendFailed *) x));
}
static void *_p_FIX__TagNotDefinedForMessageTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::TagNotDefinedForMessage *) x));
}
static void *_p_FIX__TagOutOfOrderTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::TagOutOfOrder *) x));
}
static void *_p_FIX__UnsupportedMessageTypeTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::UnsupportedMessageType *) x));
}
static void *_p_FIX__UnsupportedVersionTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::UnsupportedVersion *) x));
}
static void *_p_FIX__BeginStringTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BeginString *) x));
}
static void *_p_FIX__BoolFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::BoolField *) x));
}
static void *_p_FIX__CharFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::CharField *) x));
}
static void *_p_FIX__CheckSumFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::CheckSumField *) x));
}
static void *_p_FIX__DoubleFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::DoubleField *) x));
}
static void *_p_FIX__Int64FieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::Int64Field *) x));
}
static void *_p_FIX__IntFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::IntField *) x));
}
static void *_p_FIX__SenderCompIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SenderCompID *) x));
}
static void *_p_FIX__StringFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::StringField *) x));
}
static void *_p_FIX__TargetCompIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetCompID *) x));
}
static void *_p_FIX__UInt64FieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::UInt64Field *) x));
}
static void *_p_FIX__UtcDateFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcDateField *) x));
}
static void *_p_FIX__UtcTimeOnlyFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcTimeOnlyField *) x));
}
static void *_p_FIX__UtcTimeStampFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcTimeStampField *) x));
}
static void *_p_FIX__GroupTo_p_FIX__FieldMap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldMap *)  ((FIX::Group *) x));
}
static void *_p_FIX__HeaderTo_p_FIX__FieldMap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldMap *)  ((FIX::Header *) x));
}
static void *_p_FIX__MessageTo_p_FIX__FieldMap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldMap *)  ((FIX::Message *) x));
}
static void *_p_FIX__TrailerTo_p_FIX__FieldMap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldMap *)  ((FIX::Trailer *) x));
}
static void *_p_FIX__SSLSocketInitiatorTo_p_FIX__Initiator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Initiator *)  ((FIX::SSLSocketInitiator *) x));
}
static void *_p_FIX__SocketInitiatorTo_p_FIX__Initiator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Initiator *)  ((FIX::SocketInitiator *) x));
}
static void *_p_FIX__ThreadedSocketInitiatorTo_p_FIX__Initiator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Initiator *)  ((FIX::ThreadedSocketInitiator *) x));
}
static void *_p_FIX__FileLogTo_p_FIX__Log(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Log *)  ((FIX::FileLog *) x));
}
static void *_p_FIX__MySQLLogTo_p_FIX__Log(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Log *)  ((FIX::MySQLLog *) x));
}
static void *_p_FIX__NullLogTo_p_FIX__Log(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Log *)  ((FIX::NullLog *) x));
}
static void *_p_FIX__PostgreSQLLogTo_p_FIX__Log(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Log *)  ((FIX::PostgreSQLLog *) x));
}
static void *_p_FIX__ScreenLogTo_p_FIX__Log(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Log *)  ((FIX::ScreenLog *) x));
}
static void *_p_FIX__FileLogFactoryTo_p_FIX__LogFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::LogFactory *)  ((FIX::FileLogFactory *) x));
}
static void *_p_FIX__MySQLLogFactoryTo_p_FIX__LogFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::LogFactory *)  ((FIX::MySQLLogFactory *) x));
}
static void *_p_FIX__PostgreSQLLogFactoryTo_p_FIX__LogFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::LogFactory *)  ((FIX::PostgreSQLLogFactory *) x));
}
static void *_p_FIX__ScreenLogFactoryTo_p_FIX__LogFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::LogFactory *)  ((FIX::ScreenLogFactory *) x));
}
static void *_p_FIX__FileStoreTo_p_FIX__MessageStore(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStore *)  ((FIX::FileStore *) x));
}
static void *_p_FIX__MemoryStoreTo_p_FIX__MessageStore(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStore *)  ((FIX::MemoryStore *) x));
}
static void *_p_FIX__MySQLStoreTo_p_FIX__MessageStore(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStore *)  ((FIX::MySQLStore *) x));
}
static void *_p_FIX__NullStoreTo_p_FIX__MessageStore(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStore *)  ((FIX::NullStore *) x));
}
static void *_p_FIX__PostgreSQLStoreTo_p_FIX__MessageStore(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStore *)  ((FIX::PostgreSQLStore *) x));
}
static void *_p_FIX__FileStoreFactoryTo_p_FIX__MessageStoreFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStoreFactory *)  ((FIX::FileStoreFactory *) x));
}
static void *_p_FIX__MemoryStoreFactoryTo_p_FIX__MessageStoreFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStoreFactory *)  ((FIX::MemoryStoreFactory *) x));
}
static void *_p_FIX__MySQLStoreFactoryTo_p_FIX__MessageStoreFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStoreFactory *)  ((FIX::MySQLStoreFactory *) x));
}
static void *_p_FIX__NullStoreFactoryTo_p_FIX__MessageStoreFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStoreFactory *)  ((FIX::NullStoreFactory *) x));
}
static void *_p_FIX__PostgreSQLStoreFactoryTo_p_FIX__MessageStoreFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStoreFactory *)  ((FIX::PostgreSQLStoreFactory *) x));
}
static void *_p_FIX__SocketCloseFailedTo_p_FIX__SocketException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketCloseFailed *) x));
}
static void *_p_FIX__SocketRecvFailedTo_p_FIX__SocketException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketRecvFailed *) x));
}
static void *_p_FIX__SocketSendFailedTo_p_FIX__SocketException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketSendFailed *) x));
}
static void *_p_FIX__BeginStringTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BeginString *) x));
}
static void *_p_FIX__SenderCompIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SenderCompID *) x));
}
static void *_p_FIX__TargetCompIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TargetCompID *) x));
}
static void *_p_FIX__ConfigErrorTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::ConfigError *) x));
}
static void *_p_FIX__DataDictionaryNotFoundTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::DataDictionaryNotFound *) x));
}
static void *_p_FIX__DoNotSendTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::DoNotSend *) x));
}
static void *_p_FIX__DuplicateFieldNumberTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::DuplicateFieldNumber *) x));
}
static void *_p_FIX__ExceptionTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *)  ((FIX::Exception *) x));
}
static void *_p_FIX__FieldConvertErrorTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::FieldConvertError *) x));
}
static void *_p_FIX__FieldNotFoundTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::FieldNotFound *) x));
}
static void *_p_FIX__IOExceptionTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::IOException *) x));
}
static void *_p_FIX__IncorrectDataFormatTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::IncorrectDataFormat *) x));
}
static void *_p_FIX__IncorrectMessageStructureTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::IncorrectMessageStructure *) x));
}
static void *_p_FIX__IncorrectTagValueTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::IncorrectTagValue *) x));
}
static void *_p_FIX__InvalidMessageTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::InvalidMessage *) x));
}
static void *_p_FIX__InvalidMessageTypeTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::InvalidMessageType *) x));
}
static void *_p_FIX__InvalidTagNumberTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::InvalidTagNumber *) x));
}
static void *_p_FIX__MessageParseErrorTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::MessageParseError *) x));
}
static void *_p_FIX__NoTagValueTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::NoTagValue *) x));
}
static void *_p_FIX__RejectLogonTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::RejectLogon *) x));
}
static void *_p_FIX__RepeatedTagTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::RepeatedTag *) x));
}
static void *_p_FIX__RepeatingGroupCountMismatchTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::RepeatingGroupCountMismatch *) x));
}
static void *_p_FIX__RequiredTagMissingTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::RequiredTagMissing *) x));
}
static void *_p_FIX__RuntimeErrorTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::RuntimeError *) x));
}
static void *_p_FIX__SessionNotFoundTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::SessionNotFound *) x));
}
static void *_p_FIX__SocketCloseFailedTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *)(FIX::SocketException *) ((FIX::SocketCloseFailed *) x));
}
static void *_p_FIX__SocketExceptionTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::SocketException *) x));
}
static void *_p_FIX__SocketRecvFailedTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *)(FIX::SocketException *) ((FIX::SocketRecvFailed *) x));
}
static void *_p_FIX__SocketSendFailedTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *)(FIX::SocketException *) ((FIX::SocketSendFailed *) x));
}
static void *_p_FIX__TagNotDefinedForMessageTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::TagNotDefinedForMessage *) x));
}
static void *_p_FIX__TagOutOfOrderTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::TagOutOfOrder *) x));
}
static void *_p_FIX__UnsupportedMessageTypeTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::UnsupportedMessageType *) x));
}
static void *_p_FIX__UnsupportedVersionTo_p_std__logic_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::logic_error *) (FIX::Exception *) ((FIX::UnsupportedVersion *) x));
}
static swig_type_info _swigt__p_ApplVerID = {"_p_ApplVerID", "ApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Application = {"_p_Application", "Application *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BeginString = {"_p_BeginString", "BeginString *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DOMDocumentPtr = {"_p_DOMDocumentPtr", "DOMDocumentPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Data = {"_p_Data", "Data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DataDictionary = {"_p_DataDictionary", "DataDictionary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DataDictionaryProvider = {"_p_DataDictionaryProvider", "DataDictionaryProvider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Dictionaries = {"_p_Dictionaries", "Dictionaries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DoubleField = {"_p_DoubleField", "AmtField *|FloatField *|PercentageField *|PriceField *|PriceOffsetField *|QtyField *|DoubleField *", 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__Application = {"_p_FIX__Application", "FIX::Application *", 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__BoolField = {"_p_FIX__BoolField", "FIX::BoolField *", 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__CheckSumField = {"_p_FIX__CheckSumField", "FIX::CheckSumField *", 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__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__DatabaseConnectionID = {"_p_FIX__DatabaseConnectionID", "FIX::DatabaseConnectionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t = {"_p_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t", "FIX::MySQLConnectionPool *|FIX::DatabaseConnectionPool< FIX::MySQLConnection > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t = {"_p_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t", "FIX::PostgreSQLConnectionPool *|FIX::DatabaseConnectionPool< FIX::PostgreSQLConnection > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DateTime = {"_p_FIX__DateTime", "FIX::DateTime *", 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__DoNotSend = {"_p_FIX__DoNotSend", "FIX::DoNotSend *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DoubleField = {"_p_FIX__DoubleField", "FIX::AmtField *|FIX::FloatField *|FIX::PercentageField *|FIX::PriceField *|FIX::PriceOffsetField *|FIX::QtyField *|FIX::DoubleField *", 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__Exception = {"_p_FIX__Exception", "FIX::Exception *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldBase = {"_p_FIX__FieldBase", "FIX::FieldBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldConvertError = {"_p_FIX__FieldConvertError", "FIX::FieldConvertError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldMap = {"_p_FIX__FieldMap", "FIX::FieldMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__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__Group = {"_p_FIX__Group", "FIX::Group *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Header = {"_p_FIX__Header", "FIX::Header *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOException = {"_p_FIX__IOException", "FIX::IOException *", 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__Initiator = {"_p_FIX__Initiator", "FIX::Initiator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Int64Field = {"_p_FIX__Int64Field", "FIX::Int64Field *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IntField = {"_p_FIX__IntField", "FIX::LengthField *|FIX::NumInGroupField *|FIX::TagNumField *|FIX::IntField *", 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__LocalDate = {"_p_FIX__LocalDate", "FIX::LocalDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LocalTimeOnly = {"_p_FIX__LocalTimeOnly", "FIX::LocalTimeOnly *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LocalTimeStamp = {"_p_FIX__LocalTimeStamp", "FIX::LocalTimeStamp *", 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__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__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__MySQLConnection = {"_p_FIX__MySQLConnection", "FIX::MySQLConnection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MySQLLog = {"_p_FIX__MySQLLog", "FIX::MySQLLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MySQLLogFactory = {"_p_FIX__MySQLLogFactory", "FIX::MySQLLogFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MySQLQuery = {"_p_FIX__MySQLQuery", "FIX::MySQLQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MySQLStore = {"_p_FIX__MySQLStore", "FIX::MySQLStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MySQLStoreFactory = {"_p_FIX__MySQLStoreFactory", "FIX::MySQLStoreFactory *", 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__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__NullStore = {"_p_FIX__NullStore", "FIX::NullStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NullStoreFactory = {"_p_FIX__NullStoreFactory", "FIX::NullStoreFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PostgreSQLConnection = {"_p_FIX__PostgreSQLConnection", "FIX::PostgreSQLConnection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PostgreSQLLog = {"_p_FIX__PostgreSQLLog", "FIX::PostgreSQLLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PostgreSQLLogFactory = {"_p_FIX__PostgreSQLLogFactory", "FIX::PostgreSQLLogFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PostgreSQLQuery = {"_p_FIX__PostgreSQLQuery", "FIX::PostgreSQLQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PostgreSQLStore = {"_p_FIX__PostgreSQLStore", "FIX::PostgreSQLStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PostgreSQLStoreFactory = {"_p_FIX__PostgreSQLStoreFactory", "FIX::PostgreSQLStoreFactory *", 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__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__RequiredTagMissing = {"_p_FIX__RequiredTagMissing", "FIX::RequiredTagMissing *", 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__SSLSocketAcceptor = {"_p_FIX__SSLSocketAcceptor", "FIX::SSLSocketAcceptor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SSLSocketInitiator = {"_p_FIX__SSLSocketInitiator", "FIX::SSLSocketInitiator *", 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__SenderCompID = {"_p_FIX__SenderCompID", "FIX::SenderCompID *", 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", "std::set< FIX::SessionID >::key_type *|std::set< FIX::SessionID >::value_type *|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__SessionSettings = {"_p_FIX__SessionSettings", "FIX::SessionSettings *", 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__StringField = {"_p_FIX__StringField", "FIX::CountryField *|FIX::CurrencyField *|FIX::DataField *|FIX::DayOfMonthField *|FIX::ExchangeField *|FIX::LocalMktDateField *|FIX::MonthField *|FIX::MonthYearField *|FIX::MultipleCharValueField *|FIX::MultipleStringValueField *|FIX::MultipleValueStringField *|FIX::TzTimeOnlyField *|FIX::TzTimeStampField *|FIX::StringField *", 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 *|enum FIX::TYPE::Type *", 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__ThreadedSocketAcceptor = {"_p_FIX__ThreadedSocketAcceptor", "FIX::ThreadedSocketAcceptor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ThreadedSocketInitiator = {"_p_FIX__ThreadedSocketInitiator", "FIX::ThreadedSocketInitiator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Trailer = {"_p_FIX__Trailer", "FIX::Trailer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UInt64Field = {"_p_FIX__UInt64Field", "FIX::SeqNumField *|FIX::UInt64Field *", 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__UtcDate = {"_p_FIX__UtcDate", "FIX::UTCDATE *|FIX::UTCDATEONLY *|FIX::UtcDateOnly *|FIX::UtcDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UtcDateField = {"_p_FIX__UtcDateField", "FIX::UtcDateOnlyField *|FIX::UtcDateField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UtcTimeOnly = {"_p_FIX__UtcTimeOnly", "FIX::UTCTIMEONLY *|FIX::UtcTimeOnly *", 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__UtcTimeStamp = {"_p_FIX__UtcTimeStamp", "FIX::UTCTIMESTAMP *|FIX::UtcTimeStamp *", 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_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", "LengthField *|NumInGroupField *|SeqNumField *|TagNumField *|IntField *", 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_MYSQL = {"_p_MYSQL", "MYSQL *", 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_PGconn = {"_p_PGconn", "PGconn *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RSA = {"_p_RSA", "RSA *", 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_SessionToPort = {"_p_SessionToPort", "SessionToPort *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StringField = {"_p_StringField", "CountryField *|CurrencyField *|DataField *|DayOfMonthField *|ExchangeField *|LanguageField *|LocalMktDateField *|LocalMktTimeField *|MonthField *|MonthYearField *|MultipleCharValueField *|MultipleStringValueField *|MultipleValueStringField *|QidField *|QidRefField *|TzTimeOnlyField *|TzTimeStampField *|StringField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TimeRange = {"_p_TimeRange", "TimeRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UtcDateField = {"_p_UtcDateField", "UtcDateOnlyField *|UtcDateField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_X509 = {"_p_X509", "X509 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bool = {"_p_bool", "FIX::BOOLEAN *|bool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "FIX::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_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "FIX::AMT *|FIX::FLOAT *|FIX::PERCENTAGE *|FIX::PRICE *|FIX::PRICEOFFSET *|FIX::QTY *|double *", 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_g_value_type = {"_p_g_value_type", "g_value_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "FIX::INT *|FIX::LENGTH *|FIX::NUMINGROUP *|FIX::TAGNUM *|int32_t *|int_fast16_t *|int_fast32_t *|int_least32_t *|intptr_t *|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_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "FIX::INT64 *|int64_t *|int_fast64_t *|int_least64_t *|intmax_t *|long long *", 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_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "int16_t *|int_least16_t *|short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "int8_t *|int_fast8_t *|int_least8_t *|signed char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ssize_t = {"_p_ssize_t", "ssize_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__allocatorT_std__string_t", "std::vector< std::string >::allocator_type *|std::allocator< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_FIX__UtcTimeStamp_fF_t = {"_p_std__functionT_FIX__UtcTimeStamp_fF_t", "std::function< FIX::UtcTimeStamp () > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__lessT_FIX__SessionID_t = {"_p_std__lessT_FIX__SessionID_t", "std::less< FIX::SessionID > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__logic_error = {"_p_std__logic_error", "std::logic_error *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_FIX__SessionID_unsigned_short_t = {"_p_std__mapT_FIX__SessionID_unsigned_short_t", "FIX::SocketAcceptor::SessionToPort *|std::map< FIX::SessionID,unsigned short > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t = {"_p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t", "FIX::FieldMap::Groups *|std::map< int,std::vector< FIX::FieldMap *,std::allocator< FIX::FieldMap * > >,std::less< int >,ALLOCATOR< std::pair< int const,std::vector< FIX::FieldMap *,std::allocator< FIX::FieldMap * > > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__const_iterator = {"_p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__const_iterator", "FIX::FieldMap::g_const_iterator *|std::map< int,std::vector< FIX::FieldMap *,std::allocator< FIX::FieldMap * > >,std::less< int >,ALLOCATOR< std::pair< int const,std::vector< FIX::FieldMap *,std::allocator< FIX::FieldMap * > > > > >::const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__iterator = {"_p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__iterator", "FIX::FieldMap::g_iterator *|std::map< int,std::vector< FIX::FieldMap *,std::allocator< FIX::FieldMap * > >,std::less< int >,ALLOCATOR< std::pair< int const,std::vector< FIX::FieldMap *,std::allocator< FIX::FieldMap * > > > > >::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_std__string_t__const_iterator = {"_p_std__mapT_std__string_std__string_t__const_iterator", "FIX::Dictionary::iterator *|std::map< std::string,std::string >::const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__setT_FIX__SessionID_t = {"_p_std__setT_FIX__SessionID_t", "std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *|std::set< FIX::SessionID > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__setT_std__string_std__lessT_std__string_t_std__allocatorT_std__string_t_t = {"_p_std__setT_std__string_std__lessT_std__string_t_std__allocatorT_std__string_t_t", "std::set< std::string,std::less< std::string >,std::allocator< std::string > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string = {"_p_std__string", "FIX::COUNTRY *|FIX::CURRENCY *|FIX::DATA *|FIX::DAYOFMONTH *|FIX::EXCHANGE *|FIX::LANGUAGE *|FIX::LOCALMKTDATE *|FIX::LOCALMKTTIME *|FIX::MONTHYEAR *|FIX::MULTIPLECHARVALUE *|FIX::MULTIPLESTRINGVALUE *|FIX::MULTIPLEVALUESTRING *|FIX::STRING *|FIX::TZTIMEONLY *|FIX::TZTIMESTAMP *|FIX::XID *|FIX::XIDREF *|FIX::XMLDATA *|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__unique_ptrT_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t_t = {"_p_std__unique_ptrT_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t_t", "FIX::MySQLConnectionPoolPtr *|std::unique_ptr< FIX::DatabaseConnectionPool< FIX::MySQLConnection > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t_t = {"_p_std__unique_ptrT_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t_t", "FIX::PostgreSQLConnectionPoolPtr *|std::unique_ptr< FIX::DatabaseConnectionPool< FIX::PostgreSQLConnection > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__const_iterator = {"_p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__const_iterator", "FIX::FieldMap::const_iterator *|std::vector< FIX::FieldBase,ALLOCATOR< FIX::FieldBase > >::const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__iterator = {"_p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__iterator", "FIX::FieldMap::iterator *|std::vector< FIX::FieldBase,ALLOCATOR< FIX::FieldBase > >::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__string_t = {"_p_std__vectorT_std__string_t", "std::vector< std::string,std::allocator< std::string > > *|std::vector< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_time_t = {"_p_time_t", "time_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_tm = {"_p_tm", "tm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "uint8_t *|uint_fast8_t *|uint_least8_t *|unsigned char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uint32_t *|uint_fast16_t *|uint_fast32_t *|uint_least32_t *|uintptr_t *|unsigned int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "FIX::SEQNUM *|uint64_t *|uint_fast64_t *|uint_least64_t *|uintmax_t *|unsigned long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "uint16_t *|uint_least16_t *|unsigned short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_ApplVerID,
  &_swigt__p_Application,
  &_swigt__p_BeginString,
  &_swigt__p_DOMDocumentPtr,
  &_swigt__p_Data,
  &_swigt__p_DataDictionary,
  &_swigt__p_DataDictionaryProvider,
  &_swigt__p_Dictionaries,
  &_swigt__p_DoubleField,
  &_swigt__p_FIX__Acceptor,
  &_swigt__p_FIX__Application,
  &_swigt__p_FIX__BeginString,
  &_swigt__p_FIX__BoolField,
  &_swigt__p_FIX__CharField,
  &_swigt__p_FIX__CheckSumField,
  &_swigt__p_FIX__ConfigError,
  &_swigt__p_FIX__DataDictionary,
  &_swigt__p_FIX__DataDictionaryNotFound,
  &_swigt__p_FIX__DatabaseConnectionID,
  &_swigt__p_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t,
  &_swigt__p_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t,
  &_swigt__p_FIX__DateTime,
  &_swigt__p_FIX__Dictionary,
  &_swigt__p_FIX__DoNotSend,
  &_swigt__p_FIX__DoubleField,
  &_swigt__p_FIX__DuplicateFieldNumber,
  &_swigt__p_FIX__Exception,
  &_swigt__p_FIX__FieldBase,
  &_swigt__p_FIX__FieldConvertError,
  &_swigt__p_FIX__FieldMap,
  &_swigt__p_FIX__FieldNotFound,
  &_swigt__p_FIX__FileLog,
  &_swigt__p_FIX__FileLogFactory,
  &_swigt__p_FIX__FileStore,
  &_swigt__p_FIX__FileStoreFactory,
  &_swigt__p_FIX__Group,
  &_swigt__p_FIX__Header,
  &_swigt__p_FIX__IOException,
  &_swigt__p_FIX__IncorrectDataFormat,
  &_swigt__p_FIX__IncorrectMessageStructure,
  &_swigt__p_FIX__IncorrectTagValue,
  &_swigt__p_FIX__Initiator,
  &_swigt__p_FIX__Int64Field,
  &_swigt__p_FIX__IntField,
  &_swigt__p_FIX__InvalidMessage,
  &_swigt__p_FIX__InvalidMessageType,
  &_swigt__p_FIX__InvalidTagNumber,
  &_swigt__p_FIX__LocalDate,
  &_swigt__p_FIX__LocalTimeOnly,
  &_swigt__p_FIX__LocalTimeStamp,
  &_swigt__p_FIX__Log,
  &_swigt__p_FIX__LogFactory,
  &_swigt__p_FIX__MemoryStore,
  &_swigt__p_FIX__MemoryStoreFactory,
  &_swigt__p_FIX__Message,
  &_swigt__p_FIX__MessageParseError,
  &_swigt__p_FIX__MessageStore,
  &_swigt__p_FIX__MessageStoreExceptionWrapper,
  &_swigt__p_FIX__MessageStoreFactory,
  &_swigt__p_FIX__MessageStoreFactoryExceptionWrapper,
  &_swigt__p_FIX__MySQLConnection,
  &_swigt__p_FIX__MySQLLog,
  &_swigt__p_FIX__MySQLLogFactory,
  &_swigt__p_FIX__MySQLQuery,
  &_swigt__p_FIX__MySQLStore,
  &_swigt__p_FIX__MySQLStoreFactory,
  &_swigt__p_FIX__NoTagValue,
  &_swigt__p_FIX__NullApplication,
  &_swigt__p_FIX__NullLog,
  &_swigt__p_FIX__NullStore,
  &_swigt__p_FIX__NullStoreFactory,
  &_swigt__p_FIX__PostgreSQLConnection,
  &_swigt__p_FIX__PostgreSQLLog,
  &_swigt__p_FIX__PostgreSQLLogFactory,
  &_swigt__p_FIX__PostgreSQLQuery,
  &_swigt__p_FIX__PostgreSQLStore,
  &_swigt__p_FIX__PostgreSQLStoreFactory,
  &_swigt__p_FIX__RejectLogon,
  &_swigt__p_FIX__RepeatedTag,
  &_swigt__p_FIX__RepeatingGroupCountMismatch,
  &_swigt__p_FIX__RequiredTagMissing,
  &_swigt__p_FIX__RuntimeError,
  &_swigt__p_FIX__SSLSocketAcceptor,
  &_swigt__p_FIX__SSLSocketInitiator,
  &_swigt__p_FIX__ScreenLog,
  &_swigt__p_FIX__ScreenLogFactory,
  &_swigt__p_FIX__SenderCompID,
  &_swigt__p_FIX__Session,
  &_swigt__p_FIX__SessionID,
  &_swigt__p_FIX__SessionNotFound,
  &_swigt__p_FIX__SessionSettings,
  &_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__StringField,
  &_swigt__p_FIX__SynchronizedApplication,
  &_swigt__p_FIX__TYPE__Type,
  &_swigt__p_FIX__TagNotDefinedForMessage,
  &_swigt__p_FIX__TagOutOfOrder,
  &_swigt__p_FIX__TargetCompID,
  &_swigt__p_FIX__ThreadedSocketAcceptor,
  &_swigt__p_FIX__ThreadedSocketInitiator,
  &_swigt__p_FIX__Trailer,
  &_swigt__p_FIX__UInt64Field,
  &_swigt__p_FIX__UnsupportedMessageType,
  &_swigt__p_FIX__UnsupportedVersion,
  &_swigt__p_FIX__UtcDate,
  &_swigt__p_FIX__UtcDateField,
  &_swigt__p_FIX__UtcTimeOnly,
  &_swigt__p_FIX__UtcTimeOnlyField,
  &_swigt__p_FIX__UtcTimeStamp,
  &_swigt__p_FIX__UtcTimeStampField,
  &_swigt__p_Fields,
  &_swigt__p_Group,
  &_swigt__p_Groups,
  &_swigt__p_IntArray,
  &_swigt__p_IntField,
  &_swigt__p_Log,
  &_swigt__p_LogFactory,
  &_swigt__p_MYSQL,
  &_swigt__p_MessageStore,
  &_swigt__p_MessageStoreFactory,
  &_swigt__p_MsgType,
  &_swigt__p_Mutex,
  &_swigt__p_PGconn,
  &_swigt__p_RSA,
  &_swigt__p_Responder,
  &_swigt__p_SessionID,
  &_swigt__p_SessionToPort,
  &_swigt__p_StringField,
  &_swigt__p_TimeRange,
  &_swigt__p_UtcDateField,
  &_swigt__p_X509,
  &_swigt__p_allocator_type,
  &_swigt__p_bool,
  &_swigt__p_char,
  &_swigt__p_const_iterator,
  &_swigt__p_difference_type,
  &_swigt__p_double,
  &_swigt__p_g_const_iterator,
  &_swigt__p_g_iterator,
  &_swigt__p_g_value_type,
  &_swigt__p_int,
  &_swigt__p_iterator,
  &_swigt__p_key_type,
  &_swigt__p_long_long,
  &_swigt__p_message_order,
  &_swigt__p_p_FIX__DataDictionary,
  &_swigt__p_p_PyObject,
  &_swigt__p_short,
  &_swigt__p_signed_char,
  &_swigt__p_size_type,
  &_swigt__p_ssize_t,
  &_swigt__p_std__allocatorT_std__string_t,
  &_swigt__p_std__functionT_FIX__UtcTimeStamp_fF_t,
  &_swigt__p_std__invalid_argument,
  &_swigt__p_std__istream,
  &_swigt__p_std__lessT_FIX__SessionID_t,
  &_swigt__p_std__logic_error,
  &_swigt__p_std__mapT_FIX__SessionID_unsigned_short_t,
  &_swigt__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t,
  &_swigt__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__const_iterator,
  &_swigt__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__iterator,
  &_swigt__p_std__mapT_std__string_std__string_t__const_iterator,
  &_swigt__p_std__ostream,
  &_swigt__p_std__setT_FIX__SessionID_t,
  &_swigt__p_std__setT_std__string_std__lessT_std__string_t_std__allocatorT_std__string_t_t,
  &_swigt__p_std__string,
  &_swigt__p_std__string__size_type,
  &_swigt__p_std__unique_ptrT_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t_t,
  &_swigt__p_std__unique_ptrT_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t_t,
  &_swigt__p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__const_iterator,
  &_swigt__p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__iterator,
  &_swigt__p_std__vectorT_std__string_t,
  &_swigt__p_swig__SwigPyIterator,
  &_swigt__p_time_t,
  &_swigt__p_tm,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long_long,
  &_swigt__p_unsigned_short,
  &_swigt__p_value_type,
};

static swig_cast_info _swigc__p_ApplVerID[] = {  {&_swigt__p_ApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Application[] = {  {&_swigt__p_Application, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BeginString[] = {  {&_swigt__p_BeginString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DOMDocumentPtr[] = {  {&_swigt__p_DOMDocumentPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Data[] = {  {&_swigt__p_Data, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DataDictionary[] = {  {&_swigt__p_DataDictionary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DataDictionaryProvider[] = {  {&_swigt__p_DataDictionaryProvider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Dictionaries[] = {  {&_swigt__p_Dictionaries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DoubleField[] = {  {&_swigt__p_DoubleField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Acceptor[] = {  {&_swigt__p_FIX__Acceptor, 0, 0, 0},  {&_swigt__p_FIX__SSLSocketAcceptor, _p_FIX__SSLSocketAcceptorTo_p_FIX__Acceptor, 0, 0},  {&_swigt__p_FIX__SocketAcceptor, _p_FIX__SocketAcceptorTo_p_FIX__Acceptor, 0, 0},  {&_swigt__p_FIX__ThreadedSocketAcceptor, _p_FIX__ThreadedSocketAcceptorTo_p_FIX__Acceptor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Application[] = {  {&_swigt__p_FIX__Application, 0, 0, 0},  {&_swigt__p_FIX__NullApplication, _p_FIX__NullApplicationTo_p_FIX__Application, 0, 0},  {&_swigt__p_FIX__SynchronizedApplication, _p_FIX__SynchronizedApplicationTo_p_FIX__Application, 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__BoolField[] = {  {&_swigt__p_FIX__BoolField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CharField[] = {  {&_swigt__p_FIX__CharField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CheckSumField[] = {  {&_swigt__p_FIX__CheckSumField, 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__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__DatabaseConnectionID[] = {  {&_swigt__p_FIX__DatabaseConnectionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t[] = {  {&_swigt__p_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t[] = {  {&_swigt__p_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DateTime[] = {  {&_swigt__p_FIX__DateTime, 0, 0, 0},  {&_swigt__p_FIX__LocalDate, _p_FIX__LocalDateTo_p_FIX__DateTime, 0, 0},  {&_swigt__p_FIX__LocalTimeOnly, _p_FIX__LocalTimeOnlyTo_p_FIX__DateTime, 0, 0},  {&_swigt__p_FIX__LocalTimeStamp, _p_FIX__LocalTimeStampTo_p_FIX__DateTime, 0, 0},  {&_swigt__p_FIX__UtcDate, _p_FIX__UtcDateTo_p_FIX__DateTime, 0, 0},  {&_swigt__p_FIX__UtcTimeOnly, _p_FIX__UtcTimeOnlyTo_p_FIX__DateTime, 0, 0},  {&_swigt__p_FIX__UtcTimeStamp, _p_FIX__UtcTimeStampTo_p_FIX__DateTime, 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__DoNotSend[] = {  {&_swigt__p_FIX__DoNotSend, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DoubleField[] = {  {&_swigt__p_FIX__DoubleField, 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__Exception[] = {  {&_swigt__p_FIX__Exception, 0, 0, 0},  {&_swigt__p_FIX__ConfigError, _p_FIX__ConfigErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__DataDictionaryNotFound, _p_FIX__DataDictionaryNotFoundTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__DoNotSend, _p_FIX__DoNotSendTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__DuplicateFieldNumber, _p_FIX__DuplicateFieldNumberTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__FieldConvertError, _p_FIX__FieldConvertErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__FieldNotFound, _p_FIX__FieldNotFoundTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__IOException, _p_FIX__IOExceptionTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__IncorrectDataFormat, _p_FIX__IncorrectDataFormatTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__IncorrectMessageStructure, _p_FIX__IncorrectMessageStructureTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__IncorrectTagValue, _p_FIX__IncorrectTagValueTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__InvalidMessage, _p_FIX__InvalidMessageTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__InvalidMessageType, _p_FIX__InvalidMessageTypeTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__InvalidTagNumber, _p_FIX__InvalidTagNumberTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__MessageParseError, _p_FIX__MessageParseErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__NoTagValue, _p_FIX__NoTagValueTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RejectLogon, _p_FIX__RejectLogonTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RepeatedTag, _p_FIX__RepeatedTagTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RepeatingGroupCountMismatch, _p_FIX__RepeatingGroupCountMismatchTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RequiredTagMissing, _p_FIX__RequiredTagMissingTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RuntimeError, _p_FIX__RuntimeErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SessionNotFound, _p_FIX__SessionNotFoundTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketCloseFailed, _p_FIX__SocketCloseFailedTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketException, _p_FIX__SocketExceptionTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketRecvFailed, _p_FIX__SocketRecvFailedTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketSendFailed, _p_FIX__SocketSendFailedTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__TagNotDefinedForMessage, _p_FIX__TagNotDefinedForMessageTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__TagOutOfOrder, _p_FIX__TagOutOfOrderTo_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},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldBase[] = {  {&_swigt__p_FIX__FieldBase, 0, 0, 0},  {&_swigt__p_FIX__BeginString, _p_FIX__BeginStringTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BoolField, _p_FIX__BoolFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CharField, _p_FIX__CharFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CheckSumField, _p_FIX__CheckSumFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DoubleField, _p_FIX__DoubleFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Int64Field, _p_FIX__Int64FieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IntField, _p_FIX__IntFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SenderCompID, _p_FIX__SenderCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StringField, _p_FIX__StringFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetCompID, _p_FIX__TargetCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UInt64Field, _p_FIX__UInt64FieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UtcDateField, _p_FIX__UtcDateFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UtcTimeOnlyField, _p_FIX__UtcTimeOnlyFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UtcTimeStampField, _p_FIX__UtcTimeStampFieldTo_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__FieldMap, 0, 0, 0},  {&_swigt__p_FIX__Group, _p_FIX__GroupTo_p_FIX__FieldMap, 0, 0},  {&_swigt__p_FIX__Header, _p_FIX__HeaderTo_p_FIX__FieldMap, 0, 0},  {&_swigt__p_FIX__Message, _p_FIX__MessageTo_p_FIX__FieldMap, 0, 0},  {&_swigt__p_FIX__Trailer, _p_FIX__TrailerTo_p_FIX__FieldMap, 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__Group[] = {  {&_swigt__p_FIX__Group, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Header[] = {  {&_swigt__p_FIX__Header, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOException[] = {  {&_swigt__p_FIX__IOException, 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__Initiator[] = {  {&_swigt__p_FIX__Initiator, 0, 0, 0},  {&_swigt__p_FIX__SSLSocketInitiator, _p_FIX__SSLSocketInitiatorTo_p_FIX__Initiator, 0, 0},  {&_swigt__p_FIX__SocketInitiator, _p_FIX__SocketInitiatorTo_p_FIX__Initiator, 0, 0},  {&_swigt__p_FIX__ThreadedSocketInitiator, _p_FIX__ThreadedSocketInitiatorTo_p_FIX__Initiator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Int64Field[] = {  {&_swigt__p_FIX__Int64Field, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IntField[] = {  {&_swigt__p_FIX__IntField, 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__LocalDate[] = {  {&_swigt__p_FIX__LocalDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LocalTimeOnly[] = {  {&_swigt__p_FIX__LocalTimeOnly, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LocalTimeStamp[] = {  {&_swigt__p_FIX__LocalTimeStamp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Log[] = {  {&_swigt__p_FIX__Log, 0, 0, 0},  {&_swigt__p_FIX__FileLog, _p_FIX__FileLogTo_p_FIX__Log, 0, 0},  {&_swigt__p_FIX__MySQLLog, _p_FIX__MySQLLogTo_p_FIX__Log, 0, 0},  {&_swigt__p_FIX__NullLog, _p_FIX__NullLogTo_p_FIX__Log, 0, 0},  {&_swigt__p_FIX__PostgreSQLLog, _p_FIX__PostgreSQLLogTo_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__FileLogFactory, _p_FIX__FileLogFactoryTo_p_FIX__LogFactory, 0, 0},  {&_swigt__p_FIX__MySQLLogFactory, _p_FIX__MySQLLogFactoryTo_p_FIX__LogFactory, 0, 0},  {&_swigt__p_FIX__PostgreSQLLogFactory, _p_FIX__PostgreSQLLogFactoryTo_p_FIX__LogFactory, 0, 0},  {&_swigt__p_FIX__ScreenLogFactory, _p_FIX__ScreenLogFactoryTo_p_FIX__LogFactory, 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__MessageParseError[] = {  {&_swigt__p_FIX__MessageParseError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageStore[] = {  {&_swigt__p_FIX__MessageStore, 0, 0, 0},  {&_swigt__p_FIX__FileStore, _p_FIX__FileStoreTo_p_FIX__MessageStore, 0, 0},  {&_swigt__p_FIX__MemoryStore, _p_FIX__MemoryStoreTo_p_FIX__MessageStore, 0, 0},  {&_swigt__p_FIX__MySQLStore, _p_FIX__MySQLStoreTo_p_FIX__MessageStore, 0, 0},  {&_swigt__p_FIX__NullStore, _p_FIX__NullStoreTo_p_FIX__MessageStore, 0, 0},  {&_swigt__p_FIX__PostgreSQLStore, _p_FIX__PostgreSQLStoreTo_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__FileStoreFactory, _p_FIX__FileStoreFactoryTo_p_FIX__MessageStoreFactory, 0, 0},  {&_swigt__p_FIX__MemoryStoreFactory, _p_FIX__MemoryStoreFactoryTo_p_FIX__MessageStoreFactory, 0, 0},  {&_swigt__p_FIX__MySQLStoreFactory, _p_FIX__MySQLStoreFactoryTo_p_FIX__MessageStoreFactory, 0, 0},  {&_swigt__p_FIX__NullStoreFactory, _p_FIX__NullStoreFactoryTo_p_FIX__MessageStoreFactory, 0, 0},  {&_swigt__p_FIX__PostgreSQLStoreFactory, _p_FIX__PostgreSQLStoreFactoryTo_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__MySQLConnection[] = {  {&_swigt__p_FIX__MySQLConnection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MySQLLog[] = {  {&_swigt__p_FIX__MySQLLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MySQLLogFactory[] = {  {&_swigt__p_FIX__MySQLLogFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MySQLQuery[] = {  {&_swigt__p_FIX__MySQLQuery, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MySQLStore[] = {  {&_swigt__p_FIX__MySQLStore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MySQLStoreFactory[] = {  {&_swigt__p_FIX__MySQLStoreFactory, 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__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__NullStore[] = {  {&_swigt__p_FIX__NullStore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NullStoreFactory[] = {  {&_swigt__p_FIX__NullStoreFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PostgreSQLConnection[] = {  {&_swigt__p_FIX__PostgreSQLConnection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PostgreSQLLog[] = {  {&_swigt__p_FIX__PostgreSQLLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PostgreSQLLogFactory[] = {  {&_swigt__p_FIX__PostgreSQLLogFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PostgreSQLQuery[] = {  {&_swigt__p_FIX__PostgreSQLQuery, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PostgreSQLStore[] = {  {&_swigt__p_FIX__PostgreSQLStore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PostgreSQLStoreFactory[] = {  {&_swigt__p_FIX__PostgreSQLStoreFactory, 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__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__RequiredTagMissing[] = {  {&_swigt__p_FIX__RequiredTagMissing, 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__SSLSocketAcceptor[] = {  {&_swigt__p_FIX__SSLSocketAcceptor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SSLSocketInitiator[] = {  {&_swigt__p_FIX__SSLSocketInitiator, 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__SenderCompID[] = {  {&_swigt__p_FIX__SenderCompID, 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__SessionSettings[] = {  {&_swigt__p_FIX__SessionSettings, 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__SocketException, 0, 0, 0},  {&_swigt__p_FIX__SocketCloseFailed, _p_FIX__SocketCloseFailedTo_p_FIX__SocketException, 0, 0},  {&_swigt__p_FIX__SocketRecvFailed, _p_FIX__SocketRecvFailedTo_p_FIX__SocketException, 0, 0},  {&_swigt__p_FIX__SocketSendFailed, _p_FIX__SocketSendFailedTo_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__StringField[] = {  {&_swigt__p_FIX__StringField, 0, 0, 0},  {&_swigt__p_FIX__BeginString, _p_FIX__BeginStringTo_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},{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__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__ThreadedSocketAcceptor[] = {  {&_swigt__p_FIX__ThreadedSocketAcceptor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ThreadedSocketInitiator[] = {  {&_swigt__p_FIX__ThreadedSocketInitiator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Trailer[] = {  {&_swigt__p_FIX__Trailer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UInt64Field[] = {  {&_swigt__p_FIX__UInt64Field, 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__UtcDate[] = {  {&_swigt__p_FIX__UtcDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UtcDateField[] = {  {&_swigt__p_FIX__UtcDateField, 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__UtcTimeOnlyField[] = {  {&_swigt__p_FIX__UtcTimeOnlyField, 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__UtcTimeStampField[] = {  {&_swigt__p_FIX__UtcTimeStampField, 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_MYSQL[] = {  {&_swigt__p_MYSQL, 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_PGconn[] = {  {&_swigt__p_PGconn, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RSA[] = {  {&_swigt__p_RSA, 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_SessionToPort[] = {  {&_swigt__p_SessionToPort, 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_UtcDateField[] = {  {&_swigt__p_UtcDateField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_X509[] = {  {&_swigt__p_X509, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_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_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_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_g_value_type[] = {  {&_swigt__p_g_value_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},  {&_swigt__p_IntArray, _p_IntArrayTo_p_int, 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_key_type[] = {  {&_swigt__p_key_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_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_p_PyObject[] = {  {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ssize_t[] = {  {&_swigt__p_ssize_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = {  {&_swigt__p_std__allocatorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_FIX__UtcTimeStamp_fF_t[] = {  {&_swigt__p_std__functionT_FIX__UtcTimeStamp_fF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__istream[] = {  {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__lessT_FIX__SessionID_t[] = {  {&_swigt__p_std__lessT_FIX__SessionID_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__logic_error[] = {  {&_swigt__p_std__logic_error, 0, 0, 0},  {&_swigt__p_FIX__ConfigError, _p_FIX__ConfigErrorTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__DataDictionaryNotFound, _p_FIX__DataDictionaryNotFoundTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__DoNotSend, _p_FIX__DoNotSendTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__DuplicateFieldNumber, _p_FIX__DuplicateFieldNumberTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__Exception, _p_FIX__ExceptionTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__FieldConvertError, _p_FIX__FieldConvertErrorTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__FieldNotFound, _p_FIX__FieldNotFoundTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__IOException, _p_FIX__IOExceptionTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__IncorrectDataFormat, _p_FIX__IncorrectDataFormatTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__IncorrectMessageStructure, _p_FIX__IncorrectMessageStructureTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__IncorrectTagValue, _p_FIX__IncorrectTagValueTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__InvalidMessage, _p_FIX__InvalidMessageTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__InvalidMessageType, _p_FIX__InvalidMessageTypeTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__InvalidTagNumber, _p_FIX__InvalidTagNumberTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__MessageParseError, _p_FIX__MessageParseErrorTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__NoTagValue, _p_FIX__NoTagValueTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__RejectLogon, _p_FIX__RejectLogonTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__RepeatedTag, _p_FIX__RepeatedTagTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__RepeatingGroupCountMismatch, _p_FIX__RepeatingGroupCountMismatchTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__RequiredTagMissing, _p_FIX__RequiredTagMissingTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__RuntimeError, _p_FIX__RuntimeErrorTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__SessionNotFound, _p_FIX__SessionNotFoundTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__SocketCloseFailed, _p_FIX__SocketCloseFailedTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__SocketException, _p_FIX__SocketExceptionTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__SocketRecvFailed, _p_FIX__SocketRecvFailedTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__SocketSendFailed, _p_FIX__SocketSendFailedTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__TagNotDefinedForMessage, _p_FIX__TagNotDefinedForMessageTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__TagOutOfOrder, _p_FIX__TagOutOfOrderTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__UnsupportedMessageType, _p_FIX__UnsupportedMessageTypeTo_p_std__logic_error, 0, 0},  {&_swigt__p_FIX__UnsupportedVersion, _p_FIX__UnsupportedVersionTo_p_std__logic_error, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_FIX__SessionID_unsigned_short_t[] = {  {&_swigt__p_std__mapT_FIX__SessionID_unsigned_short_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t[] = {  {&_swigt__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__const_iterator[] = {  {&_swigt__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__iterator[] = {  {&_swigt__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_std__string_t__const_iterator[] = {  {&_swigt__p_std__mapT_std__string_std__string_t__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ostream[] = {  {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__setT_FIX__SessionID_t[] = {  {&_swigt__p_std__setT_FIX__SessionID_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__setT_std__string_std__lessT_std__string_t_std__allocatorT_std__string_t_t[] = {  {&_swigt__p_std__setT_std__string_std__lessT_std__string_t_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string__size_type[] = {  {&_swigt__p_std__string__size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t_t[] = {  {&_swigt__p_std__unique_ptrT_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t_t[] = {  {&_swigt__p_std__unique_ptrT_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__const_iterator[] = {  {&_swigt__p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__iterator[] = {  {&_swigt__p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__string_t[] = {  {&_swigt__p_std__vectorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swig__SwigPyIterator[] = {  {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_time_t[] = {  {&_swigt__p_time_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_tm[] = {  {&_swigt__p_tm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_ApplVerID,
  _swigc__p_Application,
  _swigc__p_BeginString,
  _swigc__p_DOMDocumentPtr,
  _swigc__p_Data,
  _swigc__p_DataDictionary,
  _swigc__p_DataDictionaryProvider,
  _swigc__p_Dictionaries,
  _swigc__p_DoubleField,
  _swigc__p_FIX__Acceptor,
  _swigc__p_FIX__Application,
  _swigc__p_FIX__BeginString,
  _swigc__p_FIX__BoolField,
  _swigc__p_FIX__CharField,
  _swigc__p_FIX__CheckSumField,
  _swigc__p_FIX__ConfigError,
  _swigc__p_FIX__DataDictionary,
  _swigc__p_FIX__DataDictionaryNotFound,
  _swigc__p_FIX__DatabaseConnectionID,
  _swigc__p_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t,
  _swigc__p_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t,
  _swigc__p_FIX__DateTime,
  _swigc__p_FIX__Dictionary,
  _swigc__p_FIX__DoNotSend,
  _swigc__p_FIX__DoubleField,
  _swigc__p_FIX__DuplicateFieldNumber,
  _swigc__p_FIX__Exception,
  _swigc__p_FIX__FieldBase,
  _swigc__p_FIX__FieldConvertError,
  _swigc__p_FIX__FieldMap,
  _swigc__p_FIX__FieldNotFound,
  _swigc__p_FIX__FileLog,
  _swigc__p_FIX__FileLogFactory,
  _swigc__p_FIX__FileStore,
  _swigc__p_FIX__FileStoreFactory,
  _swigc__p_FIX__Group,
  _swigc__p_FIX__Header,
  _swigc__p_FIX__IOException,
  _swigc__p_FIX__IncorrectDataFormat,
  _swigc__p_FIX__IncorrectMessageStructure,
  _swigc__p_FIX__IncorrectTagValue,
  _swigc__p_FIX__Initiator,
  _swigc__p_FIX__Int64Field,
  _swigc__p_FIX__IntField,
  _swigc__p_FIX__InvalidMessage,
  _swigc__p_FIX__InvalidMessageType,
  _swigc__p_FIX__InvalidTagNumber,
  _swigc__p_FIX__LocalDate,
  _swigc__p_FIX__LocalTimeOnly,
  _swigc__p_FIX__LocalTimeStamp,
  _swigc__p_FIX__Log,
  _swigc__p_FIX__LogFactory,
  _swigc__p_FIX__MemoryStore,
  _swigc__p_FIX__MemoryStoreFactory,
  _swigc__p_FIX__Message,
  _swigc__p_FIX__MessageParseError,
  _swigc__p_FIX__MessageStore,
  _swigc__p_FIX__MessageStoreExceptionWrapper,
  _swigc__p_FIX__MessageStoreFactory,
  _swigc__p_FIX__MessageStoreFactoryExceptionWrapper,
  _swigc__p_FIX__MySQLConnection,
  _swigc__p_FIX__MySQLLog,
  _swigc__p_FIX__MySQLLogFactory,
  _swigc__p_FIX__MySQLQuery,
  _swigc__p_FIX__MySQLStore,
  _swigc__p_FIX__MySQLStoreFactory,
  _swigc__p_FIX__NoTagValue,
  _swigc__p_FIX__NullApplication,
  _swigc__p_FIX__NullLog,
  _swigc__p_FIX__NullStore,
  _swigc__p_FIX__NullStoreFactory,
  _swigc__p_FIX__PostgreSQLConnection,
  _swigc__p_FIX__PostgreSQLLog,
  _swigc__p_FIX__PostgreSQLLogFactory,
  _swigc__p_FIX__PostgreSQLQuery,
  _swigc__p_FIX__PostgreSQLStore,
  _swigc__p_FIX__PostgreSQLStoreFactory,
  _swigc__p_FIX__RejectLogon,
  _swigc__p_FIX__RepeatedTag,
  _swigc__p_FIX__RepeatingGroupCountMismatch,
  _swigc__p_FIX__RequiredTagMissing,
  _swigc__p_FIX__RuntimeError,
  _swigc__p_FIX__SSLSocketAcceptor,
  _swigc__p_FIX__SSLSocketInitiator,
  _swigc__p_FIX__ScreenLog,
  _swigc__p_FIX__ScreenLogFactory,
  _swigc__p_FIX__SenderCompID,
  _swigc__p_FIX__Session,
  _swigc__p_FIX__SessionID,
  _swigc__p_FIX__SessionNotFound,
  _swigc__p_FIX__SessionSettings,
  _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__StringField,
  _swigc__p_FIX__SynchronizedApplication,
  _swigc__p_FIX__TYPE__Type,
  _swigc__p_FIX__TagNotDefinedForMessage,
  _swigc__p_FIX__TagOutOfOrder,
  _swigc__p_FIX__TargetCompID,
  _swigc__p_FIX__ThreadedSocketAcceptor,
  _swigc__p_FIX__ThreadedSocketInitiator,
  _swigc__p_FIX__Trailer,
  _swigc__p_FIX__UInt64Field,
  _swigc__p_FIX__UnsupportedMessageType,
  _swigc__p_FIX__UnsupportedVersion,
  _swigc__p_FIX__UtcDate,
  _swigc__p_FIX__UtcDateField,
  _swigc__p_FIX__UtcTimeOnly,
  _swigc__p_FIX__UtcTimeOnlyField,
  _swigc__p_FIX__UtcTimeStamp,
  _swigc__p_FIX__UtcTimeStampField,
  _swigc__p_Fields,
  _swigc__p_Group,
  _swigc__p_Groups,
  _swigc__p_IntArray,
  _swigc__p_IntField,
  _swigc__p_Log,
  _swigc__p_LogFactory,
  _swigc__p_MYSQL,
  _swigc__p_MessageStore,
  _swigc__p_MessageStoreFactory,
  _swigc__p_MsgType,
  _swigc__p_Mutex,
  _swigc__p_PGconn,
  _swigc__p_RSA,
  _swigc__p_Responder,
  _swigc__p_SessionID,
  _swigc__p_SessionToPort,
  _swigc__p_StringField,
  _swigc__p_TimeRange,
  _swigc__p_UtcDateField,
  _swigc__p_X509,
  _swigc__p_allocator_type,
  _swigc__p_bool,
  _swigc__p_char,
  _swigc__p_const_iterator,
  _swigc__p_difference_type,
  _swigc__p_double,
  _swigc__p_g_const_iterator,
  _swigc__p_g_iterator,
  _swigc__p_g_value_type,
  _swigc__p_int,
  _swigc__p_iterator,
  _swigc__p_key_type,
  _swigc__p_long_long,
  _swigc__p_message_order,
  _swigc__p_p_FIX__DataDictionary,
  _swigc__p_p_PyObject,
  _swigc__p_short,
  _swigc__p_signed_char,
  _swigc__p_size_type,
  _swigc__p_ssize_t,
  _swigc__p_std__allocatorT_std__string_t,
  _swigc__p_std__functionT_FIX__UtcTimeStamp_fF_t,
  _swigc__p_std__invalid_argument,
  _swigc__p_std__istream,
  _swigc__p_std__lessT_FIX__SessionID_t,
  _swigc__p_std__logic_error,
  _swigc__p_std__mapT_FIX__SessionID_unsigned_short_t,
  _swigc__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t,
  _swigc__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__const_iterator,
  _swigc__p_std__mapT_int_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_std__lessT_int_t_ALLOCATORT_std__pairT_int_const_std__vectorT_FIX__FieldMap_p_std__allocatorT_FIX__FieldMap_p_t_t_t_t_t__iterator,
  _swigc__p_std__mapT_std__string_std__string_t__const_iterator,
  _swigc__p_std__ostream,
  _swigc__p_std__setT_FIX__SessionID_t,
  _swigc__p_std__setT_std__string_std__lessT_std__string_t_std__allocatorT_std__string_t_t,
  _swigc__p_std__string,
  _swigc__p_std__string__size_type,
  _swigc__p_std__unique_ptrT_FIX__DatabaseConnectionPoolT_FIX__MySQLConnection_t_t,
  _swigc__p_std__unique_ptrT_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t_t,
  _swigc__p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__const_iterator,
  _swigc__p_std__vectorT_FIX__FieldBase_ALLOCATORT_FIX__FieldBase_t_t__iterator,
  _swigc__p_std__vectorT_std__string_t,
  _swigc__p_swig__SwigPyIterator,
  _swigc__p_time_t,
  _swigc__p_tm,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long_long,
  _swigc__p_unsigned_short,
  _swigc__p_value_type,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif

#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif

SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = 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 %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  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
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        SWIG_Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------
   * Patch %callback methods' docstrings to hold the callback ptrs
   * -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        const swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              memcpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              memcpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
#ifdef __cplusplus
}
#endif




#ifdef __cplusplus
extern "C" {
#endif
  
  /* -----------------------------------------------------------------------------
   * Method creation and docstring support functions
   * ----------------------------------------------------------------------------- */
  
  /* -----------------------------------------------------------------------------
   * Function to find the method definition with the correct docstring for the
   * proxy module as opposed to the low-level API
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
    /* Find the function in the modified method table */
    size_t offset = 0;
    int found = 0;
    while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
      if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
        found = 1;
        break;
      }
      offset++;
    }
    /* Use the copy with the modified docstring if available */
    return found ? &SwigMethods_proxydocs[offset] : NULL;
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyInstanceMethod_New() used in Python 3
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
#if PY_VERSION_HEX >= 0x03000000
    return PyInstanceMethod_New(func);
#else
    return PyMethod_New(func, NULL, NULL);
#endif
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyStaticMethod_New()
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
    return PyStaticMethod_New(func);
  }
  
#ifdef __cplusplus
}
#endif




/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
  PyObject *m, *d, *md, *globals;
  
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    SWIG_name,
    NULL,
    -1,
    SwigMethods,
    NULL,
    NULL,
    NULL,
    NULL
  };
#endif
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    SwigPyObject_own,
    SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  PyTypeObject *swigpyobject;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* Metaclass is used to implement static member variables */
  metatype = SwigPyObjectType();
  assert(metatype);
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
  SwigPyObject_type();
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#if PY_VERSION_HEX >= 0x03000000
  m = PyModule_Create(&SWIG_module);
#else
  m = Py_InitModule(SWIG_name, SwigMethods);
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  swigpyobject = SwigPyObject_TypeOnce();
  
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = swigpyobject;
  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
    return NULL;
# else
    return;
# endif
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  SWIG_Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  
  // thread safe initialization
  swig::container_owner_attribute();
  
  
#ifdef SWIGPYTHON
  PyDateTime_IMPORT;
#endif
  
  globals = SWIG_globals();
  if (!globals) {
    PyErr_SetString(PyExc_TypeError, "Failure to create SWIG globals.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  PyDict_SetItemString(md, "cvar", globals);
  SWIG_Python_SetConstant(d, "EnumUnknown",SWIG_From_int(static_cast< int >(FIX::TYPE::Unknown)));
  SWIG_Python_SetConstant(d, "EnumString",SWIG_From_int(static_cast< int >(FIX::TYPE::String)));
  SWIG_Python_SetConstant(d, "EnumChar",SWIG_From_int(static_cast< int >(FIX::TYPE::Char)));
  SWIG_Python_SetConstant(d, "EnumPrice",SWIG_From_int(static_cast< int >(FIX::TYPE::Price)));
  SWIG_Python_SetConstant(d, "EnumInt",SWIG_From_int(static_cast< int >(FIX::TYPE::Int)));
  SWIG_Python_SetConstant(d, "EnumAmt",SWIG_From_int(static_cast< int >(FIX::TYPE::Amt)));
  SWIG_Python_SetConstant(d, "EnumQty",SWIG_From_int(static_cast< int >(FIX::TYPE::Qty)));
  SWIG_Python_SetConstant(d, "EnumCurrency",SWIG_From_int(static_cast< int >(FIX::TYPE::Currency)));
  SWIG_Python_SetConstant(d, "EnumMultipleValueString",SWIG_From_int(static_cast< int >(FIX::TYPE::MultipleValueString)));
  SWIG_Python_SetConstant(d, "EnumMultipleStringValue",SWIG_From_int(static_cast< int >(FIX::TYPE::MultipleStringValue)));
  SWIG_Python_SetConstant(d, "EnumMultipleCharValue",SWIG_From_int(static_cast< int >(FIX::TYPE::MultipleCharValue)));
  SWIG_Python_SetConstant(d, "EnumExchange",SWIG_From_int(static_cast< int >(FIX::TYPE::Exchange)));
  SWIG_Python_SetConstant(d, "EnumUtcTimeStamp",SWIG_From_int(static_cast< int >(FIX::TYPE::UtcTimeStamp)));
  SWIG_Python_SetConstant(d, "EnumBoolean",SWIG_From_int(static_cast< int >(FIX::TYPE::Boolean)));
  SWIG_Python_SetConstant(d, "EnumLocalMktTime",SWIG_From_int(static_cast< int >(FIX::TYPE::LocalMktTime)));
  SWIG_Python_SetConstant(d, "EnumLocalMktDate",SWIG_From_int(static_cast< int >(FIX::TYPE::LocalMktDate)));
  SWIG_Python_SetConstant(d, "EnumData",SWIG_From_int(static_cast< int >(FIX::TYPE::Data)));
  SWIG_Python_SetConstant(d, "EnumFloat",SWIG_From_int(static_cast< int >(FIX::TYPE::Float)));
  SWIG_Python_SetConstant(d, "EnumPriceOffset",SWIG_From_int(static_cast< int >(FIX::TYPE::PriceOffset)));
  SWIG_Python_SetConstant(d, "EnumMonthYear",SWIG_From_int(static_cast< int >(FIX::TYPE::MonthYear)));
  SWIG_Python_SetConstant(d, "EnumDayOfMonth",SWIG_From_int(static_cast< int >(FIX::TYPE::DayOfMonth)));
  SWIG_Python_SetConstant(d, "EnumUtcDate",SWIG_From_int(static_cast< int >(FIX::TYPE::UtcDate)));
  SWIG_Python_SetConstant(d, "EnumUtcDateOnly",SWIG_From_int(static_cast< int >(FIX::TYPE::UtcDateOnly)));
  SWIG_Python_SetConstant(d, "EnumUtcTimeOnly",SWIG_From_int(static_cast< int >(FIX::TYPE::UtcTimeOnly)));
  SWIG_Python_SetConstant(d, "EnumNumInGroup",SWIG_From_int(static_cast< int >(FIX::TYPE::NumInGroup)));
  SWIG_Python_SetConstant(d, "EnumPercentage",SWIG_From_int(static_cast< int >(FIX::TYPE::Percentage)));
  SWIG_Python_SetConstant(d, "EnumSeqNum",SWIG_From_int(static_cast< int >(FIX::TYPE::SeqNum)));
  SWIG_Python_SetConstant(d, "EnumTagNum",SWIG_From_int(static_cast< int >(FIX::TYPE::TagNum)));
  SWIG_Python_SetConstant(d, "EnumLength",SWIG_From_int(static_cast< int >(FIX::TYPE::Length)));
  SWIG_Python_SetConstant(d, "EnumCountry",SWIG_From_int(static_cast< int >(FIX::TYPE::Country)));
  SWIG_Python_SetConstant(d, "EnumTzTimeOnly",SWIG_From_int(static_cast< int >(FIX::TYPE::TzTimeOnly)));
  SWIG_Python_SetConstant(d, "EnumTzTimeStamp",SWIG_From_int(static_cast< int >(FIX::TYPE::TzTimeStamp)));
  SWIG_Python_SetConstant(d, "EnumXmlData",SWIG_From_int(static_cast< int >(FIX::TYPE::XmlData)));
  SWIG_Python_SetConstant(d, "EnumLanguage",SWIG_From_int(static_cast< int >(FIX::TYPE::Language)));
  SWIG_Python_SetConstant(d, "EnumXid",SWIG_From_int(static_cast< int >(FIX::TYPE::Xid)));
  SWIG_Python_SetConstant(d, "EnumXidRef",SWIG_From_int(static_cast< int >(FIX::TYPE::XidRef)));
  SWIG_Python_SetConstant(d, "BeginString_tag",SWIG_From_int(static_cast< int >(FIX::BeginString::tag)));
  SWIG_Python_SetConstant(d, "SenderCompID_tag",SWIG_From_int(static_cast< int >(FIX::SenderCompID::tag)));
  SWIG_Python_SetConstant(d, "TargetCompID_tag",SWIG_From_int(static_cast< int >(FIX::TargetCompID::tag)));
  SWIG_Python_SetConstant(d, "SSL_HANDSHAKE_FAILED",SWIG_From_int(static_cast< int >(FIX::SSL_HANDSHAKE_FAILED)));
  SWIG_Python_SetConstant(d, "SSL_HANDSHAKE_SUCCEDED",SWIG_From_int(static_cast< int >(FIX::SSL_HANDSHAKE_SUCCEDED)));
  SWIG_Python_SetConstant(d, "SSL_HANDSHAKE_IN_PROGRESS",SWIG_From_int(static_cast< int >(FIX::SSL_HANDSHAKE_IN_PROGRESS)));
  
#ifndef _MSC_VER
  struct sigaction new_action, old_action;
  new_action.sa_handler = SIG_DFL;
  sigemptyset( &new_action.sa_mask );
  new_action.sa_flags = 0;
  sigaction( SIGINT, &new_action, &old_action );
#endif
  
  
  /* Initialize threading */
  SWIG_PYTHON_INITIALIZE_THREADS;
  SWIG_addvarlink(globals, "PRECISION_FACTOR", Swig_var_PRECISION_FACTOR_get, Swig_var_PRECISION_FACTOR_set);
  SWIG_addvarlink(globals, "BeginString_FIXT11", Swig_var_BeginString_FIXT11_get, Swig_var_BeginString_FIXT11_set);
  SWIG_addvarlink(globals, "BeginString_FIX50", Swig_var_BeginString_FIX50_get, Swig_var_BeginString_FIX50_set);
  SWIG_addvarlink(globals, "BeginString_FIX44", Swig_var_BeginString_FIX44_get, Swig_var_BeginString_FIX44_set);
  SWIG_addvarlink(globals, "BeginString_FIX43", Swig_var_BeginString_FIX43_get, Swig_var_BeginString_FIX43_set);
  SWIG_addvarlink(globals, "BeginString_FIX42", Swig_var_BeginString_FIX42_get, Swig_var_BeginString_FIX42_set);
  SWIG_addvarlink(globals, "BeginString_FIX41", Swig_var_BeginString_FIX41_get, Swig_var_BeginString_FIX41_set);
  SWIG_addvarlink(globals, "BeginString_FIX40", Swig_var_BeginString_FIX40_get, Swig_var_BeginString_FIX40_set);
  SWIG_addvarlink(globals, "SessionRejectReason_INVALID_TAG_NUMBER_TEXT", Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_TEXT_get, Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_TEXT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_REQUIRED_TAG_MISSING_TEXT", Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_TEXT_get, Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_TEXT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT", Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT_get, Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_UNDEFINED_TAG_TEXT", Swig_var_SessionRejectReason_UNDEFINED_TAG_TEXT_get, Swig_var_SessionRejectReason_UNDEFINED_TAG_TEXT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT", Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT_get, Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_VALUE_IS_INCORRECT_TEXT", Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_TEXT_get, Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_TEXT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT", Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT_get, Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_DECRYPTION_PROBLEM_TEXT", Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_TEXT_get, Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_TEXT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_SIGNATURE_PROBLEM_TEXT", Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_TEXT_get, Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_TEXT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_COMPID_PROBLEM_TEXT", Swig_var_SessionRejectReason_COMPID_PROBLEM_TEXT_get, Swig_var_SessionRejectReason_COMPID_PROBLEM_TEXT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT", Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT_get, Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_INVALID_MSGTYPE_TEXT", Swig_var_SessionRejectReason_INVALID_MSGTYPE_TEXT_get, Swig_var_SessionRejectReason_INVALID_MSGTYPE_TEXT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT", Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT_get, Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT", Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT_get, Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT", Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT_get, Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_OTHER_TEXT", Swig_var_BusinessRejectReason_OTHER_TEXT_get, Swig_var_BusinessRejectReason_OTHER_TEXT_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_UNKNOWN_ID_TEXT", Swig_var_BusinessRejectReason_UNKNOWN_ID_TEXT_get, Swig_var_BusinessRejectReason_UNKNOWN_ID_TEXT_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_UNKNOWN_SECURITY_TEXT", Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_TEXT_get, Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_TEXT_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT", Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT_get, Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT", Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT_get, Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT", Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT_get, Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_NOT_AUTHORIZED_TEXT", Swig_var_BusinessRejectReason_NOT_AUTHORIZED_TEXT_get, Swig_var_BusinessRejectReason_NOT_AUTHORIZED_TEXT_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_DELIVER_TO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT", Swig_var_BusinessRejectReason_DELIVER_TO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT_get, Swig_var_BusinessRejectReason_DELIVER_TO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT_set);
  SWIG_addvarlink(globals, "MsgType_Heartbeat", Swig_var_MsgType_Heartbeat_get, Swig_var_MsgType_Heartbeat_set);
  SWIG_addvarlink(globals, "MsgType_TestRequest", Swig_var_MsgType_TestRequest_get, Swig_var_MsgType_TestRequest_set);
  SWIG_addvarlink(globals, "MsgType_ResendRequest", Swig_var_MsgType_ResendRequest_get, Swig_var_MsgType_ResendRequest_set);
  SWIG_addvarlink(globals, "MsgType_Reject", Swig_var_MsgType_Reject_get, Swig_var_MsgType_Reject_set);
  SWIG_addvarlink(globals, "MsgType_SequenceReset", Swig_var_MsgType_SequenceReset_get, Swig_var_MsgType_SequenceReset_set);
  SWIG_addvarlink(globals, "MsgType_Logout", Swig_var_MsgType_Logout_get, Swig_var_MsgType_Logout_set);
  SWIG_addvarlink(globals, "MsgType_Logon", Swig_var_MsgType_Logon_get, Swig_var_MsgType_Logon_set);
  SWIG_addvarlink(globals, "MsgType_XMLnonFIX", Swig_var_MsgType_XMLnonFIX_get, Swig_var_MsgType_XMLnonFIX_set);
  SWIG_addvarlink(globals, "MsgType_IOI", Swig_var_MsgType_IOI_get, Swig_var_MsgType_IOI_set);
  SWIG_addvarlink(globals, "MsgType_Advertisement", Swig_var_MsgType_Advertisement_get, Swig_var_MsgType_Advertisement_set);
  SWIG_addvarlink(globals, "MsgType_ExecutionReport", Swig_var_MsgType_ExecutionReport_get, Swig_var_MsgType_ExecutionReport_set);
  SWIG_addvarlink(globals, "MsgType_OrderCancelReject", Swig_var_MsgType_OrderCancelReject_get, Swig_var_MsgType_OrderCancelReject_set);
  SWIG_addvarlink(globals, "MsgType_News", Swig_var_MsgType_News_get, Swig_var_MsgType_News_set);
  SWIG_addvarlink(globals, "MsgType_Email", Swig_var_MsgType_Email_get, Swig_var_MsgType_Email_set);
  SWIG_addvarlink(globals, "MsgType_NewOrderSingle", Swig_var_MsgType_NewOrderSingle_get, Swig_var_MsgType_NewOrderSingle_set);
  SWIG_addvarlink(globals, "MsgType_NewOrderList", Swig_var_MsgType_NewOrderList_get, Swig_var_MsgType_NewOrderList_set);
  SWIG_addvarlink(globals, "MsgType_OrderCancelRequest", Swig_var_MsgType_OrderCancelRequest_get, Swig_var_MsgType_OrderCancelRequest_set);
  SWIG_addvarlink(globals, "MsgType_OrderCancelReplaceRequest", Swig_var_MsgType_OrderCancelReplaceRequest_get, Swig_var_MsgType_OrderCancelReplaceRequest_set);
  SWIG_addvarlink(globals, "MsgType_OrderStatusRequest", Swig_var_MsgType_OrderStatusRequest_get, Swig_var_MsgType_OrderStatusRequest_set);
  SWIG_addvarlink(globals, "MsgType_Allocation", Swig_var_MsgType_Allocation_get, Swig_var_MsgType_Allocation_set);
  SWIG_addvarlink(globals, "MsgType_ListCancelRequest", Swig_var_MsgType_ListCancelRequest_get, Swig_var_MsgType_ListCancelRequest_set);
  SWIG_addvarlink(globals, "MsgType_ListExecute", Swig_var_MsgType_ListExecute_get, Swig_var_MsgType_ListExecute_set);
  SWIG_addvarlink(globals, "MsgType_ListStatusRequest", Swig_var_MsgType_ListStatusRequest_get, Swig_var_MsgType_ListStatusRequest_set);
  SWIG_addvarlink(globals, "MsgType_ListStatus", Swig_var_MsgType_ListStatus_get, Swig_var_MsgType_ListStatus_set);
  SWIG_addvarlink(globals, "MsgType_AllocationInstructionAck", Swig_var_MsgType_AllocationInstructionAck_get, Swig_var_MsgType_AllocationInstructionAck_set);
  SWIG_addvarlink(globals, "MsgType_DontKnowTrade", Swig_var_MsgType_DontKnowTrade_get, Swig_var_MsgType_DontKnowTrade_set);
  SWIG_addvarlink(globals, "MsgType_QuoteRequest", Swig_var_MsgType_QuoteRequest_get, Swig_var_MsgType_QuoteRequest_set);
  SWIG_addvarlink(globals, "MsgType_Quote", Swig_var_MsgType_Quote_get, Swig_var_MsgType_Quote_set);
  SWIG_addvarlink(globals, "MsgType_SettlementInstructions", Swig_var_MsgType_SettlementInstructions_get, Swig_var_MsgType_SettlementInstructions_set);
  SWIG_addvarlink(globals, "MsgType_MarketDataRequest", Swig_var_MsgType_MarketDataRequest_get, Swig_var_MsgType_MarketDataRequest_set);
  SWIG_addvarlink(globals, "MsgType_MarketDataSnapshotFullRefresh", Swig_var_MsgType_MarketDataSnapshotFullRefresh_get, Swig_var_MsgType_MarketDataSnapshotFullRefresh_set);
  SWIG_addvarlink(globals, "MsgType_MarketDataIncrementalRefresh", Swig_var_MsgType_MarketDataIncrementalRefresh_get, Swig_var_MsgType_MarketDataIncrementalRefresh_set);
  SWIG_addvarlink(globals, "MsgType_MarketDataRequestReject", Swig_var_MsgType_MarketDataRequestReject_get, Swig_var_MsgType_MarketDataRequestReject_set);
  SWIG_addvarlink(globals, "MsgType_QuoteCancel", Swig_var_MsgType_QuoteCancel_get, Swig_var_MsgType_QuoteCancel_set);
  SWIG_addvarlink(globals, "MsgType_QuoteStatusRequest", Swig_var_MsgType_QuoteStatusRequest_get, Swig_var_MsgType_QuoteStatusRequest_set);
  SWIG_addvarlink(globals, "MsgType_QuoteAcknowledgement", Swig_var_MsgType_QuoteAcknowledgement_get, Swig_var_MsgType_QuoteAcknowledgement_set);
  SWIG_addvarlink(globals, "MsgType_SecurityDefinitionRequest", Swig_var_MsgType_SecurityDefinitionRequest_get, Swig_var_MsgType_SecurityDefinitionRequest_set);
  SWIG_addvarlink(globals, "MsgType_SecurityDefinition", Swig_var_MsgType_SecurityDefinition_get, Swig_var_MsgType_SecurityDefinition_set);
  SWIG_addvarlink(globals, "MsgType_SecurityStatusRequest", Swig_var_MsgType_SecurityStatusRequest_get, Swig_var_MsgType_SecurityStatusRequest_set);
  SWIG_addvarlink(globals, "MsgType_SecurityStatus", Swig_var_MsgType_SecurityStatus_get, Swig_var_MsgType_SecurityStatus_set);
  SWIG_addvarlink(globals, "MsgType_TradingSessionStatusRequest", Swig_var_MsgType_TradingSessionStatusRequest_get, Swig_var_MsgType_TradingSessionStatusRequest_set);
  SWIG_addvarlink(globals, "MsgType_TradingSessionStatus", Swig_var_MsgType_TradingSessionStatus_get, Swig_var_MsgType_TradingSessionStatus_set);
  SWIG_addvarlink(globals, "MsgType_MassQuote", Swig_var_MsgType_MassQuote_get, Swig_var_MsgType_MassQuote_set);
  SWIG_addvarlink(globals, "MsgType_BusinessMessageReject", Swig_var_MsgType_BusinessMessageReject_get, Swig_var_MsgType_BusinessMessageReject_set);
  SWIG_addvarlink(globals, "MsgType_BidRequest", Swig_var_MsgType_BidRequest_get, Swig_var_MsgType_BidRequest_set);
  SWIG_addvarlink(globals, "MsgType_BidResponse", Swig_var_MsgType_BidResponse_get, Swig_var_MsgType_BidResponse_set);
  SWIG_addvarlink(globals, "MsgType_ListStrikePrice", Swig_var_MsgType_ListStrikePrice_get, Swig_var_MsgType_ListStrikePrice_set);
  SWIG_addvarlink(globals, "MsgType_AllocationAck", Swig_var_MsgType_AllocationAck_get, Swig_var_MsgType_AllocationAck_set);
  SWIG_addvarlink(globals, "MsgType_MassQuoteAcknowledgement", Swig_var_MsgType_MassQuoteAcknowledgement_get, Swig_var_MsgType_MassQuoteAcknowledgement_set);
  SWIG_addvarlink(globals, "MsgType_RegistrationInstructions", Swig_var_MsgType_RegistrationInstructions_get, Swig_var_MsgType_RegistrationInstructions_set);
  SWIG_addvarlink(globals, "MsgType_RegistrationInstructionsResponse", Swig_var_MsgType_RegistrationInstructionsResponse_get, Swig_var_MsgType_RegistrationInstructionsResponse_set);
  SWIG_addvarlink(globals, "MsgType_OrderMassCancelRequest", Swig_var_MsgType_OrderMassCancelRequest_get, Swig_var_MsgType_OrderMassCancelRequest_set);
  SWIG_addvarlink(globals, "MsgType_OrderMassCancelReport", Swig_var_MsgType_OrderMassCancelReport_get, Swig_var_MsgType_OrderMassCancelReport_set);
  SWIG_addvarlink(globals, "MsgType_NewOrderCross", Swig_var_MsgType_NewOrderCross_get, Swig_var_MsgType_NewOrderCross_set);
  SWIG_addvarlink(globals, "MsgType_CrossOrderCancelReplaceRequest", Swig_var_MsgType_CrossOrderCancelReplaceRequest_get, Swig_var_MsgType_CrossOrderCancelReplaceRequest_set);
  SWIG_addvarlink(globals, "MsgType_CrossOrderCancelRequest", Swig_var_MsgType_CrossOrderCancelRequest_get, Swig_var_MsgType_CrossOrderCancelRequest_set);
  SWIG_addvarlink(globals, "MsgType_SecurityTypeRequest", Swig_var_MsgType_SecurityTypeRequest_get, Swig_var_MsgType_SecurityTypeRequest_set);
  SWIG_addvarlink(globals, "MsgType_SecurityTypes", Swig_var_MsgType_SecurityTypes_get, Swig_var_MsgType_SecurityTypes_set);
  SWIG_addvarlink(globals, "MsgType_SecurityListRequest", Swig_var_MsgType_SecurityListRequest_get, Swig_var_MsgType_SecurityListRequest_set);
  SWIG_addvarlink(globals, "MsgType_SecurityList", Swig_var_MsgType_SecurityList_get, Swig_var_MsgType_SecurityList_set);
  SWIG_addvarlink(globals, "MsgType_DerivativeSecurityListRequest", Swig_var_MsgType_DerivativeSecurityListRequest_get, Swig_var_MsgType_DerivativeSecurityListRequest_set);
  SWIG_addvarlink(globals, "MsgType_DerivativeSecurityList", Swig_var_MsgType_DerivativeSecurityList_get, Swig_var_MsgType_DerivativeSecurityList_set);
  SWIG_addvarlink(globals, "MsgType_NewOrderMultileg", Swig_var_MsgType_NewOrderMultileg_get, Swig_var_MsgType_NewOrderMultileg_set);
  SWIG_addvarlink(globals, "MsgType_MultilegOrderCancelReplaceRequest", Swig_var_MsgType_MultilegOrderCancelReplaceRequest_get, Swig_var_MsgType_MultilegOrderCancelReplaceRequest_set);
  SWIG_addvarlink(globals, "MsgType_TradeCaptureReportRequest", Swig_var_MsgType_TradeCaptureReportRequest_get, Swig_var_MsgType_TradeCaptureReportRequest_set);
  SWIG_addvarlink(globals, "MsgType_TradeCaptureReport", Swig_var_MsgType_TradeCaptureReport_get, Swig_var_MsgType_TradeCaptureReport_set);
  SWIG_addvarlink(globals, "MsgType_OrderMassStatusRequest", Swig_var_MsgType_OrderMassStatusRequest_get, Swig_var_MsgType_OrderMassStatusRequest_set);
  SWIG_addvarlink(globals, "MsgType_QuoteRequestReject", Swig_var_MsgType_QuoteRequestReject_get, Swig_var_MsgType_QuoteRequestReject_set);
  SWIG_addvarlink(globals, "MsgType_RFQRequest", Swig_var_MsgType_RFQRequest_get, Swig_var_MsgType_RFQRequest_set);
  SWIG_addvarlink(globals, "MsgType_QuoteStatusReport", Swig_var_MsgType_QuoteStatusReport_get, Swig_var_MsgType_QuoteStatusReport_set);
  SWIG_addvarlink(globals, "MsgType_AllocationInstruction", Swig_var_MsgType_AllocationInstruction_get, Swig_var_MsgType_AllocationInstruction_set);
  SWIG_addvarlink(globals, "MsgType_MultilegOrderCancelReplace", Swig_var_MsgType_MultilegOrderCancelReplace_get, Swig_var_MsgType_MultilegOrderCancelReplace_set);
  SWIG_addvarlink(globals, "MsgType_QuoteResponse", Swig_var_MsgType_QuoteResponse_get, Swig_var_MsgType_QuoteResponse_set);
  SWIG_addvarlink(globals, "MsgType_Confirmation", Swig_var_MsgType_Confirmation_get, Swig_var_MsgType_Confirmation_set);
  SWIG_addvarlink(globals, "MsgType_PositionMaintenanceRequest", Swig_var_MsgType_PositionMaintenanceRequest_get, Swig_var_MsgType_PositionMaintenanceRequest_set);
  SWIG_addvarlink(globals, "MsgType_PositionMaintenanceReport", Swig_var_MsgType_PositionMaintenanceReport_get, Swig_var_MsgType_PositionMaintenanceReport_set);
  SWIG_addvarlink(globals, "MsgType_RequestForPositions", Swig_var_MsgType_RequestForPositions_get, Swig_var_MsgType_RequestForPositions_set);
  SWIG_addvarlink(globals, "MsgType_RequestForPositionsAck", Swig_var_MsgType_RequestForPositionsAck_get, Swig_var_MsgType_RequestForPositionsAck_set);
  SWIG_addvarlink(globals, "MsgType_PositionReport", Swig_var_MsgType_PositionReport_get, Swig_var_MsgType_PositionReport_set);
  SWIG_addvarlink(globals, "MsgType_TradeCaptureReportRequestAck", Swig_var_MsgType_TradeCaptureReportRequestAck_get, Swig_var_MsgType_TradeCaptureReportRequestAck_set);
  SWIG_addvarlink(globals, "MsgType_TradeCaptureReportAck", Swig_var_MsgType_TradeCaptureReportAck_get, Swig_var_MsgType_TradeCaptureReportAck_set);
  SWIG_addvarlink(globals, "MsgType_AllocationReport", Swig_var_MsgType_AllocationReport_get, Swig_var_MsgType_AllocationReport_set);
  SWIG_addvarlink(globals, "MsgType_AllocationReportAck", Swig_var_MsgType_AllocationReportAck_get, Swig_var_MsgType_AllocationReportAck_set);
  SWIG_addvarlink(globals, "MsgType_ConfirmationAck", Swig_var_MsgType_ConfirmationAck_get, Swig_var_MsgType_ConfirmationAck_set);
  SWIG_addvarlink(globals, "MsgType_SettlementInstructionRequest", Swig_var_MsgType_SettlementInstructionRequest_get, Swig_var_MsgType_SettlementInstructionRequest_set);
  SWIG_addvarlink(globals, "MsgType_AssignmentReport", Swig_var_MsgType_AssignmentReport_get, Swig_var_MsgType_AssignmentReport_set);
  SWIG_addvarlink(globals, "MsgType_CollateralRequest", Swig_var_MsgType_CollateralRequest_get, Swig_var_MsgType_CollateralRequest_set);
  SWIG_addvarlink(globals, "MsgType_CollateralAssignment", Swig_var_MsgType_CollateralAssignment_get, Swig_var_MsgType_CollateralAssignment_set);
  SWIG_addvarlink(globals, "MsgType_CollateralResponse", Swig_var_MsgType_CollateralResponse_get, Swig_var_MsgType_CollateralResponse_set);
  SWIG_addvarlink(globals, "MsgType_CollateralReport", Swig_var_MsgType_CollateralReport_get, Swig_var_MsgType_CollateralReport_set);
  SWIG_addvarlink(globals, "MsgType_CollateralInquiry", Swig_var_MsgType_CollateralInquiry_get, Swig_var_MsgType_CollateralInquiry_set);
  SWIG_addvarlink(globals, "MsgType_NetworkCounterpartySystemStatusRequest", Swig_var_MsgType_NetworkCounterpartySystemStatusRequest_get, Swig_var_MsgType_NetworkCounterpartySystemStatusRequest_set);
  SWIG_addvarlink(globals, "MsgType_NetworkCounterpartySystemStatusResponse", Swig_var_MsgType_NetworkCounterpartySystemStatusResponse_get, Swig_var_MsgType_NetworkCounterpartySystemStatusResponse_set);
  SWIG_addvarlink(globals, "MsgType_UserRequest", Swig_var_MsgType_UserRequest_get, Swig_var_MsgType_UserRequest_set);
  SWIG_addvarlink(globals, "MsgType_UserResponse", Swig_var_MsgType_UserResponse_get, Swig_var_MsgType_UserResponse_set);
  SWIG_addvarlink(globals, "MsgType_CollateralInquiryAck", Swig_var_MsgType_CollateralInquiryAck_get, Swig_var_MsgType_CollateralInquiryAck_set);
  SWIG_addvarlink(globals, "MsgType_ConfirmationRequest", Swig_var_MsgType_ConfirmationRequest_get, Swig_var_MsgType_ConfirmationRequest_set);
  SWIG_addvarlink(globals, "MsgType_ContraryIntentionReport", Swig_var_MsgType_ContraryIntentionReport_get, Swig_var_MsgType_ContraryIntentionReport_set);
  SWIG_addvarlink(globals, "MsgType_SecurityDefinitionUpdateReport", Swig_var_MsgType_SecurityDefinitionUpdateReport_get, Swig_var_MsgType_SecurityDefinitionUpdateReport_set);
  SWIG_addvarlink(globals, "MsgType_SecurityListUpdateReport", Swig_var_MsgType_SecurityListUpdateReport_get, Swig_var_MsgType_SecurityListUpdateReport_set);
  SWIG_addvarlink(globals, "MsgType_AdjustedPositionReport", Swig_var_MsgType_AdjustedPositionReport_get, Swig_var_MsgType_AdjustedPositionReport_set);
  SWIG_addvarlink(globals, "MsgType_AllocationInstructionAlert", Swig_var_MsgType_AllocationInstructionAlert_get, Swig_var_MsgType_AllocationInstructionAlert_set);
  SWIG_addvarlink(globals, "MsgType_ExecutionAcknowledgement", Swig_var_MsgType_ExecutionAcknowledgement_get, Swig_var_MsgType_ExecutionAcknowledgement_set);
  SWIG_addvarlink(globals, "MsgType_TradingSessionList", Swig_var_MsgType_TradingSessionList_get, Swig_var_MsgType_TradingSessionList_set);
  SWIG_addvarlink(globals, "MsgType_TradingSessionListRequest", Swig_var_MsgType_TradingSessionListRequest_get, Swig_var_MsgType_TradingSessionListRequest_set);
  SWIG_addvarlink(globals, "MsgType_SettlementObligationReport", Swig_var_MsgType_SettlementObligationReport_get, Swig_var_MsgType_SettlementObligationReport_set);
  SWIG_addvarlink(globals, "MsgType_DerivativeSecurityListUpdateReport", Swig_var_MsgType_DerivativeSecurityListUpdateReport_get, Swig_var_MsgType_DerivativeSecurityListUpdateReport_set);
  SWIG_addvarlink(globals, "MsgType_TradingSessionListUpdateReport", Swig_var_MsgType_TradingSessionListUpdateReport_get, Swig_var_MsgType_TradingSessionListUpdateReport_set);
  SWIG_addvarlink(globals, "MsgType_MarketDefinitionRequest", Swig_var_MsgType_MarketDefinitionRequest_get, Swig_var_MsgType_MarketDefinitionRequest_set);
  SWIG_addvarlink(globals, "MsgType_MarketDefinition", Swig_var_MsgType_MarketDefinition_get, Swig_var_MsgType_MarketDefinition_set);
  SWIG_addvarlink(globals, "MsgType_MarketDefinitionUpdateReport", Swig_var_MsgType_MarketDefinitionUpdateReport_get, Swig_var_MsgType_MarketDefinitionUpdateReport_set);
  SWIG_addvarlink(globals, "MsgType_UserNotification", Swig_var_MsgType_UserNotification_get, Swig_var_MsgType_UserNotification_set);
  SWIG_addvarlink(globals, "MsgType_OrderMassActionReport", Swig_var_MsgType_OrderMassActionReport_get, Swig_var_MsgType_OrderMassActionReport_set);
  SWIG_addvarlink(globals, "MsgType_OrderMassActionRequest", Swig_var_MsgType_OrderMassActionRequest_get, Swig_var_MsgType_OrderMassActionRequest_set);
  SWIG_addvarlink(globals, "MsgType_ApplicationMessageRequest", Swig_var_MsgType_ApplicationMessageRequest_get, Swig_var_MsgType_ApplicationMessageRequest_set);
  SWIG_addvarlink(globals, "MsgType_ApplicationMessageRequestAck", Swig_var_MsgType_ApplicationMessageRequestAck_get, Swig_var_MsgType_ApplicationMessageRequestAck_set);
  SWIG_addvarlink(globals, "MsgType_ApplicationMessageReport", Swig_var_MsgType_ApplicationMessageReport_get, Swig_var_MsgType_ApplicationMessageReport_set);
  SWIG_addvarlink(globals, "MsgType_MassQuoteAck", Swig_var_MsgType_MassQuoteAck_get, Swig_var_MsgType_MassQuoteAck_set);
  SWIG_addvarlink(globals, "MsgType_ExecutionAck", Swig_var_MsgType_ExecutionAck_get, Swig_var_MsgType_ExecutionAck_set);
  SWIG_addvarlink(globals, "MsgType_StreamAssignmentRequest", Swig_var_MsgType_StreamAssignmentRequest_get, Swig_var_MsgType_StreamAssignmentRequest_set);
  SWIG_addvarlink(globals, "MsgType_StreamAssignmentReport", Swig_var_MsgType_StreamAssignmentReport_get, Swig_var_MsgType_StreamAssignmentReport_set);
  SWIG_addvarlink(globals, "MsgType_StreamAssignmentReportACK", Swig_var_MsgType_StreamAssignmentReportACK_get, Swig_var_MsgType_StreamAssignmentReportACK_set);
  SWIG_addvarlink(globals, "MsgType_MarginRequirementInquiry", Swig_var_MsgType_MarginRequirementInquiry_get, Swig_var_MsgType_MarginRequirementInquiry_set);
  SWIG_addvarlink(globals, "MsgType_MarginRequirementInquiryAck", Swig_var_MsgType_MarginRequirementInquiryAck_get, Swig_var_MsgType_MarginRequirementInquiryAck_set);
  SWIG_addvarlink(globals, "MsgType_MarginRequirementReport", Swig_var_MsgType_MarginRequirementReport_get, Swig_var_MsgType_MarginRequirementReport_set);
  SWIG_addvarlink(globals, "MsgType_PartyDetailsListRequest", Swig_var_MsgType_PartyDetailsListRequest_get, Swig_var_MsgType_PartyDetailsListRequest_set);
  SWIG_addvarlink(globals, "MsgType_PartyDetailsListReport", Swig_var_MsgType_PartyDetailsListReport_get, Swig_var_MsgType_PartyDetailsListReport_set);
  SWIG_addvarlink(globals, "MsgType_PartyDetailsListUpdateReport", Swig_var_MsgType_PartyDetailsListUpdateReport_get, Swig_var_MsgType_PartyDetailsListUpdateReport_set);
  SWIG_addvarlink(globals, "MsgType_PartyRiskLimitsRequest", Swig_var_MsgType_PartyRiskLimitsRequest_get, Swig_var_MsgType_PartyRiskLimitsRequest_set);
  SWIG_addvarlink(globals, "MsgType_PartyRiskLimitsReport", Swig_var_MsgType_PartyRiskLimitsReport_get, Swig_var_MsgType_PartyRiskLimitsReport_set);
  SWIG_addvarlink(globals, "MsgType_SecurityMassStatusRequest", Swig_var_MsgType_SecurityMassStatusRequest_get, Swig_var_MsgType_SecurityMassStatusRequest_set);
  SWIG_addvarlink(globals, "MsgType_SecurityMassStatus", Swig_var_MsgType_SecurityMassStatus_get, Swig_var_MsgType_SecurityMassStatus_set);
  SWIG_addvarlink(globals, "MsgType_AccountSummaryReport", Swig_var_MsgType_AccountSummaryReport_get, Swig_var_MsgType_AccountSummaryReport_set);
  SWIG_addvarlink(globals, "MsgType_PartyRiskLimitsUpdateReport", Swig_var_MsgType_PartyRiskLimitsUpdateReport_get, Swig_var_MsgType_PartyRiskLimitsUpdateReport_set);
  SWIG_addvarlink(globals, "MsgType_PartyRiskLimitsDefinitionRequest", Swig_var_MsgType_PartyRiskLimitsDefinitionRequest_get, Swig_var_MsgType_PartyRiskLimitsDefinitionRequest_set);
  SWIG_addvarlink(globals, "MsgType_PartyRiskLimitsDefinitionRequestAck", Swig_var_MsgType_PartyRiskLimitsDefinitionRequestAck_get, Swig_var_MsgType_PartyRiskLimitsDefinitionRequestAck_set);
  SWIG_addvarlink(globals, "MsgType_PartyEntitlementsRequest", Swig_var_MsgType_PartyEntitlementsRequest_get, Swig_var_MsgType_PartyEntitlementsRequest_set);
  SWIG_addvarlink(globals, "MsgType_PartyEntitlementsReport", Swig_var_MsgType_PartyEntitlementsReport_get, Swig_var_MsgType_PartyEntitlementsReport_set);
  SWIG_addvarlink(globals, "MsgType_QuoteAck", Swig_var_MsgType_QuoteAck_get, Swig_var_MsgType_QuoteAck_set);
  SWIG_addvarlink(globals, "MsgType_PartyDetailsDefinitionRequest", Swig_var_MsgType_PartyDetailsDefinitionRequest_get, Swig_var_MsgType_PartyDetailsDefinitionRequest_set);
  SWIG_addvarlink(globals, "MsgType_PartyDetailsDefinitionRequestAck", Swig_var_MsgType_PartyDetailsDefinitionRequestAck_get, Swig_var_MsgType_PartyDetailsDefinitionRequestAck_set);
  SWIG_addvarlink(globals, "MsgType_PartyEntitlementsUpdateReport", Swig_var_MsgType_PartyEntitlementsUpdateReport_get, Swig_var_MsgType_PartyEntitlementsUpdateReport_set);
  SWIG_addvarlink(globals, "MsgType_PartyEntitlementsDefinitionRequest", Swig_var_MsgType_PartyEntitlementsDefinitionRequest_get, Swig_var_MsgType_PartyEntitlementsDefinitionRequest_set);
  SWIG_addvarlink(globals, "MsgType_PartyEntitlementsDefinitionRequestAck", Swig_var_MsgType_PartyEntitlementsDefinitionRequestAck_get, Swig_var_MsgType_PartyEntitlementsDefinitionRequestAck_set);
  SWIG_addvarlink(globals, "MsgType_TradeMatchReport", Swig_var_MsgType_TradeMatchReport_get, Swig_var_MsgType_TradeMatchReport_set);
  SWIG_addvarlink(globals, "MsgType_TradeMatchReportAck", Swig_var_MsgType_TradeMatchReportAck_get, Swig_var_MsgType_TradeMatchReportAck_set);
  SWIG_addvarlink(globals, "MsgType_PartyRiskLimitsReportAck", Swig_var_MsgType_PartyRiskLimitsReportAck_get, Swig_var_MsgType_PartyRiskLimitsReportAck_set);
  SWIG_addvarlink(globals, "MsgType_PartyRiskLimitCheckRequest", Swig_var_MsgType_PartyRiskLimitCheckRequest_get, Swig_var_MsgType_PartyRiskLimitCheckRequest_set);
  SWIG_addvarlink(globals, "MsgType_PartyRiskLimitCheckRequestAck", Swig_var_MsgType_PartyRiskLimitCheckRequestAck_get, Swig_var_MsgType_PartyRiskLimitCheckRequestAck_set);
  SWIG_addvarlink(globals, "MsgType_PartyActionRequest", Swig_var_MsgType_PartyActionRequest_get, Swig_var_MsgType_PartyActionRequest_set);
  SWIG_addvarlink(globals, "MsgType_PartyActionReport", Swig_var_MsgType_PartyActionReport_get, Swig_var_MsgType_PartyActionReport_set);
  SWIG_addvarlink(globals, "MsgType_MassOrder", Swig_var_MsgType_MassOrder_get, Swig_var_MsgType_MassOrder_set);
  SWIG_addvarlink(globals, "MsgType_MassOrderAck", Swig_var_MsgType_MassOrderAck_get, Swig_var_MsgType_MassOrderAck_set);
  SWIG_addvarlink(globals, "MsgType_PositionTransferInstruction", Swig_var_MsgType_PositionTransferInstruction_get, Swig_var_MsgType_PositionTransferInstruction_set);
  SWIG_addvarlink(globals, "MsgType_PositionTransferInstructionAck", Swig_var_MsgType_PositionTransferInstructionAck_get, Swig_var_MsgType_PositionTransferInstructionAck_set);
  SWIG_addvarlink(globals, "MsgType_PositionTransferReport", Swig_var_MsgType_PositionTransferReport_get, Swig_var_MsgType_PositionTransferReport_set);
  SWIG_addvarlink(globals, "MsgType_MarketDataStatisticsRequest", Swig_var_MsgType_MarketDataStatisticsRequest_get, Swig_var_MsgType_MarketDataStatisticsRequest_set);
  SWIG_addvarlink(globals, "MsgType_MarketDataStatisticsReport", Swig_var_MsgType_MarketDataStatisticsReport_get, Swig_var_MsgType_MarketDataStatisticsReport_set);
  SWIG_addvarlink(globals, "MsgType_CollateralReportAck", Swig_var_MsgType_CollateralReportAck_get, Swig_var_MsgType_CollateralReportAck_set);
  SWIG_addvarlink(globals, "MsgType_MarketDataReport", Swig_var_MsgType_MarketDataReport_get, Swig_var_MsgType_MarketDataReport_set);
  SWIG_addvarlink(globals, "MsgType_CrossRequest", Swig_var_MsgType_CrossRequest_get, Swig_var_MsgType_CrossRequest_set);
  SWIG_addvarlink(globals, "MsgType_CrossRequestAck", Swig_var_MsgType_CrossRequestAck_get, Swig_var_MsgType_CrossRequestAck_set);
  SWIG_addvarlink(globals, "MsgType_AllocationInstructionAlertRequest", Swig_var_MsgType_AllocationInstructionAlertRequest_get, Swig_var_MsgType_AllocationInstructionAlertRequest_set);
  SWIG_addvarlink(globals, "MsgType_AllocationInstructionAlertRequestAck", Swig_var_MsgType_AllocationInstructionAlertRequestAck_get, Swig_var_MsgType_AllocationInstructionAlertRequestAck_set);
  SWIG_addvarlink(globals, "MsgType_TradeAggregationRequest", Swig_var_MsgType_TradeAggregationRequest_get, Swig_var_MsgType_TradeAggregationRequest_set);
  SWIG_addvarlink(globals, "MsgType_TradeAggregationReport", Swig_var_MsgType_TradeAggregationReport_get, Swig_var_MsgType_TradeAggregationReport_set);
  SWIG_addvarlink(globals, "MsgType_PayManagementReport", Swig_var_MsgType_PayManagementReport_get, Swig_var_MsgType_PayManagementReport_set);
  SWIG_addvarlink(globals, "MsgType_PayManagementReportAck", Swig_var_MsgType_PayManagementReportAck_get, Swig_var_MsgType_PayManagementReportAck_set);
  SWIG_addvarlink(globals, "MsgType_PayManagementRequest", Swig_var_MsgType_PayManagementRequest_get, Swig_var_MsgType_PayManagementRequest_set);
  SWIG_addvarlink(globals, "MsgType_PayManagementRequestAck", Swig_var_MsgType_PayManagementRequestAck_get, Swig_var_MsgType_PayManagementRequestAck_set);
  SWIG_addvarlink(globals, "PossDupFlag_NO", Swig_var_PossDupFlag_NO_get, Swig_var_PossDupFlag_NO_set);
  SWIG_addvarlink(globals, "PossDupFlag_YES", Swig_var_PossDupFlag_YES_get, Swig_var_PossDupFlag_YES_set);
  SWIG_addvarlink(globals, "PossResend_NO", Swig_var_PossResend_NO_get, Swig_var_PossResend_NO_set);
  SWIG_addvarlink(globals, "PossResend_YES", Swig_var_PossResend_YES_get, Swig_var_PossResend_YES_set);
  SWIG_addvarlink(globals, "EncryptMethod_NONE_OTHER", Swig_var_EncryptMethod_NONE_OTHER_get, Swig_var_EncryptMethod_NONE_OTHER_set);
  SWIG_addvarlink(globals, "EncryptMethod_PKCS", Swig_var_EncryptMethod_PKCS_get, Swig_var_EncryptMethod_PKCS_set);
  SWIG_addvarlink(globals, "EncryptMethod_DES", Swig_var_EncryptMethod_DES_get, Swig_var_EncryptMethod_DES_set);
  SWIG_addvarlink(globals, "EncryptMethod_PKCSDES", Swig_var_EncryptMethod_PKCSDES_get, Swig_var_EncryptMethod_PKCSDES_set);
  SWIG_addvarlink(globals, "EncryptMethod_PGPDES", Swig_var_EncryptMethod_PGPDES_get, Swig_var_EncryptMethod_PGPDES_set);
  SWIG_addvarlink(globals, "EncryptMethod_PGPDESMD5", Swig_var_EncryptMethod_PGPDESMD5_get, Swig_var_EncryptMethod_PGPDESMD5_set);
  SWIG_addvarlink(globals, "EncryptMethod_PEMDESMD5", Swig_var_EncryptMethod_PEMDESMD5_get, Swig_var_EncryptMethod_PEMDESMD5_set);
  SWIG_addvarlink(globals, "EncryptMethod_NONE", Swig_var_EncryptMethod_NONE_get, Swig_var_EncryptMethod_NONE_set);
  SWIG_addvarlink(globals, "EncryptMethod_PEM", Swig_var_EncryptMethod_PEM_get, Swig_var_EncryptMethod_PEM_set);
  SWIG_addvarlink(globals, "GapFillFlag_NO", Swig_var_GapFillFlag_NO_get, Swig_var_GapFillFlag_NO_set);
  SWIG_addvarlink(globals, "GapFillFlag_YES", Swig_var_GapFillFlag_YES_get, Swig_var_GapFillFlag_YES_set);
  SWIG_addvarlink(globals, "ResetSeqNumFlag_NO", Swig_var_ResetSeqNumFlag_NO_get, Swig_var_ResetSeqNumFlag_NO_set);
  SWIG_addvarlink(globals, "ResetSeqNumFlag_YES", Swig_var_ResetSeqNumFlag_YES_get, Swig_var_ResetSeqNumFlag_YES_set);
  SWIG_addvarlink(globals, "MessageEncoding_EUCJP", Swig_var_MessageEncoding_EUCJP_get, Swig_var_MessageEncoding_EUCJP_set);
  SWIG_addvarlink(globals, "MessageEncoding_ISO2022_JP", Swig_var_MessageEncoding_ISO2022_JP_get, Swig_var_MessageEncoding_ISO2022_JP_set);
  SWIG_addvarlink(globals, "MessageEncoding_SHIFT_JIS", Swig_var_MessageEncoding_SHIFT_JIS_get, Swig_var_MessageEncoding_SHIFT_JIS_set);
  SWIG_addvarlink(globals, "MessageEncoding_UTF8", Swig_var_MessageEncoding_UTF8_get, Swig_var_MessageEncoding_UTF8_set);
  SWIG_addvarlink(globals, "SessionRejectReason_INVALID_TAG_NUMBER", Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_get, Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_set);
  SWIG_addvarlink(globals, "SessionRejectReason_REQUIRED_TAG_MISSING", Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_get, Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_set);
  SWIG_addvarlink(globals, "SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE", Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_get, Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_set);
  SWIG_addvarlink(globals, "SessionRejectReason_UNDEFINED_TAG", Swig_var_SessionRejectReason_UNDEFINED_TAG_get, Swig_var_SessionRejectReason_UNDEFINED_TAG_set);
  SWIG_addvarlink(globals, "SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE", Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_get, Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_set);
  SWIG_addvarlink(globals, "SessionRejectReason_VALUE_IS_INCORRECT", Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_get, Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_set);
  SWIG_addvarlink(globals, "SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE", Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_get, Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_set);
  SWIG_addvarlink(globals, "SessionRejectReason_DECRYPTION_PROBLEM", Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_get, Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_set);
  SWIG_addvarlink(globals, "SessionRejectReason_SIGNATURE_PROBLEM", Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_get, Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_set);
  SWIG_addvarlink(globals, "SessionRejectReason_COMPID_PROBLEM", Swig_var_SessionRejectReason_COMPID_PROBLEM_get, Swig_var_SessionRejectReason_COMPID_PROBLEM_set);
  SWIG_addvarlink(globals, "SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM", Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_get, Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_set);
  SWIG_addvarlink(globals, "SessionRejectReason_INVALID_MSGTYPE", Swig_var_SessionRejectReason_INVALID_MSGTYPE_get, Swig_var_SessionRejectReason_INVALID_MSGTYPE_set);
  SWIG_addvarlink(globals, "SessionRejectReason_XML_VALIDATION_ERROR", Swig_var_SessionRejectReason_XML_VALIDATION_ERROR_get, Swig_var_SessionRejectReason_XML_VALIDATION_ERROR_set);
  SWIG_addvarlink(globals, "SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE", Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_get, Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_set);
  SWIG_addvarlink(globals, "SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER", Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_get, Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_set);
  SWIG_addvarlink(globals, "SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER", Swig_var_SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER_get, Swig_var_SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER_set);
  SWIG_addvarlink(globals, "SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP", Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_get, Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_set);
  SWIG_addvarlink(globals, "SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER", Swig_var_SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER_get, Swig_var_SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER_set);
  SWIG_addvarlink(globals, "SessionRejectReason_INVALID_UNSUPPORTED_APPLICATION_VERSION", Swig_var_SessionRejectReason_INVALID_UNSUPPORTED_APPLICATION_VERSION_get, Swig_var_SessionRejectReason_INVALID_UNSUPPORTED_APPLICATION_VERSION_set);
  SWIG_addvarlink(globals, "SessionRejectReason_OTHER", Swig_var_SessionRejectReason_OTHER_get, Swig_var_SessionRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "SessionRejectReason_SENDING_TIME_ACCURACY_PROBLEM", Swig_var_SessionRejectReason_SENDING_TIME_ACCURACY_PROBLEM_get, Swig_var_SessionRejectReason_SENDING_TIME_ACCURACY_PROBLEM_set);
  SWIG_addvarlink(globals, "SessionRejectReason_INVALID_MSG_TYPE", Swig_var_SessionRejectReason_INVALID_MSG_TYPE_get, Swig_var_SessionRejectReason_INVALID_MSG_TYPE_set);
  SWIG_addvarlink(globals, "SessionRejectReason_COMP_ID_PROBLEM", Swig_var_SessionRejectReason_COMP_ID_PROBLEM_get, Swig_var_SessionRejectReason_COMP_ID_PROBLEM_set);
  SWIG_addvarlink(globals, "SessionRejectReason_NON", Swig_var_SessionRejectReason_NON_get, Swig_var_SessionRejectReason_NON_set);
  SWIG_addvarlink(globals, "SessionRejectReason_INCORRECT_NUM_IN_GROUP_COUNT_FOR_REPEATING_GROUP", Swig_var_SessionRejectReason_INCORRECT_NUM_IN_GROUP_COUNT_FOR_REPEATING_GROUP_get, Swig_var_SessionRejectReason_INCORRECT_NUM_IN_GROUP_COUNT_FOR_REPEATING_GROUP_set);
  SWIG_addvarlink(globals, "TestMessageIndicator_NO", Swig_var_TestMessageIndicator_NO_get, Swig_var_TestMessageIndicator_NO_set);
  SWIG_addvarlink(globals, "TestMessageIndicator_YES", Swig_var_TestMessageIndicator_YES_get, Swig_var_TestMessageIndicator_YES_set);
  SWIG_addvarlink(globals, "ApplVerID_FIX27", Swig_var_ApplVerID_FIX27_get, Swig_var_ApplVerID_FIX27_set);
  SWIG_addvarlink(globals, "ApplVerID_FIX30", Swig_var_ApplVerID_FIX30_get, Swig_var_ApplVerID_FIX30_set);
  SWIG_addvarlink(globals, "ApplVerID_FIX40", Swig_var_ApplVerID_FIX40_get, Swig_var_ApplVerID_FIX40_set);
  SWIG_addvarlink(globals, "ApplVerID_FIX41", Swig_var_ApplVerID_FIX41_get, Swig_var_ApplVerID_FIX41_set);
  SWIG_addvarlink(globals, "ApplVerID_FIX42", Swig_var_ApplVerID_FIX42_get, Swig_var_ApplVerID_FIX42_set);
  SWIG_addvarlink(globals, "ApplVerID_FIX43", Swig_var_ApplVerID_FIX43_get, Swig_var_ApplVerID_FIX43_set);
  SWIG_addvarlink(globals, "ApplVerID_FIX44", Swig_var_ApplVerID_FIX44_get, Swig_var_ApplVerID_FIX44_set);
  SWIG_addvarlink(globals, "ApplVerID_FIX50", Swig_var_ApplVerID_FIX50_get, Swig_var_ApplVerID_FIX50_set);
  SWIG_addvarlink(globals, "ApplVerID_FIX50_SP1", Swig_var_ApplVerID_FIX50_SP1_get, Swig_var_ApplVerID_FIX50_SP1_set);
  SWIG_addvarlink(globals, "ApplVerID_FIX50_SP2", Swig_var_ApplVerID_FIX50_SP2_get, Swig_var_ApplVerID_FIX50_SP2_set);
  SWIG_addvarlink(globals, "SessionStatus_SESSION_ACTIVE", Swig_var_SessionStatus_SESSION_ACTIVE_get, Swig_var_SessionStatus_SESSION_ACTIVE_set);
  SWIG_addvarlink(globals, "SessionStatus_SESSION_PASSWORD_CHANGED", Swig_var_SessionStatus_SESSION_PASSWORD_CHANGED_get, Swig_var_SessionStatus_SESSION_PASSWORD_CHANGED_set);
  SWIG_addvarlink(globals, "SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE", Swig_var_SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE_get, Swig_var_SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE_set);
  SWIG_addvarlink(globals, "SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY", Swig_var_SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY_get, Swig_var_SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY_set);
  SWIG_addvarlink(globals, "SessionStatus_SESSION_LOGOUT_COMPLETE", Swig_var_SessionStatus_SESSION_LOGOUT_COMPLETE_get, Swig_var_SessionStatus_SESSION_LOGOUT_COMPLETE_set);
  SWIG_addvarlink(globals, "SessionStatus_INVALID_USERNAME_OR_PASSWORD", Swig_var_SessionStatus_INVALID_USERNAME_OR_PASSWORD_get, Swig_var_SessionStatus_INVALID_USERNAME_OR_PASSWORD_set);
  SWIG_addvarlink(globals, "SessionStatus_ACCOUNT_LOCKED", Swig_var_SessionStatus_ACCOUNT_LOCKED_get, Swig_var_SessionStatus_ACCOUNT_LOCKED_set);
  SWIG_addvarlink(globals, "SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME", Swig_var_SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME_get, Swig_var_SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME_set);
  SWIG_addvarlink(globals, "SessionStatus_PASSWORD_EXPIRED", Swig_var_SessionStatus_PASSWORD_EXPIRED_get, Swig_var_SessionStatus_PASSWORD_EXPIRED_set);
  SWIG_addvarlink(globals, "AdvSide_BUY", Swig_var_AdvSide_BUY_get, Swig_var_AdvSide_BUY_set);
  SWIG_addvarlink(globals, "AdvSide_SELL", Swig_var_AdvSide_SELL_get, Swig_var_AdvSide_SELL_set);
  SWIG_addvarlink(globals, "AdvSide_TRADE", Swig_var_AdvSide_TRADE_get, Swig_var_AdvSide_TRADE_set);
  SWIG_addvarlink(globals, "AdvSide_CROSS", Swig_var_AdvSide_CROSS_get, Swig_var_AdvSide_CROSS_set);
  SWIG_addvarlink(globals, "AdvTransType_CANCEL", Swig_var_AdvTransType_CANCEL_get, Swig_var_AdvTransType_CANCEL_set);
  SWIG_addvarlink(globals, "AdvTransType_NEW", Swig_var_AdvTransType_NEW_get, Swig_var_AdvTransType_NEW_set);
  SWIG_addvarlink(globals, "AdvTransType_REPLACE", Swig_var_AdvTransType_REPLACE_get, Swig_var_AdvTransType_REPLACE_set);
  SWIG_addvarlink(globals, "CommType_PER_UNIT", Swig_var_CommType_PER_UNIT_get, Swig_var_CommType_PER_UNIT_set);
  SWIG_addvarlink(globals, "CommType_PERCENT", Swig_var_CommType_PERCENT_get, Swig_var_CommType_PERCENT_set);
  SWIG_addvarlink(globals, "CommType_ABSOLUTE", Swig_var_CommType_ABSOLUTE_get, Swig_var_CommType_ABSOLUTE_set);
  SWIG_addvarlink(globals, "CommType_POINTS_PER_BOND_OR_CONTRACT", Swig_var_CommType_POINTS_PER_BOND_OR_CONTRACT_get, Swig_var_CommType_POINTS_PER_BOND_OR_CONTRACT_set);
  SWIG_addvarlink(globals, "CommType_PERCENTAGE_WAIVED_ENHANCED_UNITS", Swig_var_CommType_PERCENTAGE_WAIVED_ENHANCED_UNITS_get, Swig_var_CommType_PERCENTAGE_WAIVED_ENHANCED_UNITS_set);
  SWIG_addvarlink(globals, "CommType_PERCENTAGE_WAIVED_CASH_DISCOUNT", Swig_var_CommType_PERCENTAGE_WAIVED_CASH_DISCOUNT_get, Swig_var_CommType_PERCENTAGE_WAIVED_CASH_DISCOUNT_set);
  SWIG_addvarlink(globals, "CommType_BASIS_POINTS", Swig_var_CommType_BASIS_POINTS_get, Swig_var_CommType_BASIS_POINTS_set);
  SWIG_addvarlink(globals, "CommType_AMOUNT_PER_CONTRACT", Swig_var_CommType_AMOUNT_PER_CONTRACT_get, Swig_var_CommType_AMOUNT_PER_CONTRACT_set);
  SWIG_addvarlink(globals, "ExecInst_STAY_ON_OFFER_SIDE", Swig_var_ExecInst_STAY_ON_OFFER_SIDE_get, Swig_var_ExecInst_STAY_ON_OFFER_SIDE_set);
  SWIG_addvarlink(globals, "ExecInst_NOT_HELD", Swig_var_ExecInst_NOT_HELD_get, Swig_var_ExecInst_NOT_HELD_set);
  SWIG_addvarlink(globals, "ExecInst_WORK", Swig_var_ExecInst_WORK_get, Swig_var_ExecInst_WORK_set);
  SWIG_addvarlink(globals, "ExecInst_GO_ALONG", Swig_var_ExecInst_GO_ALONG_get, Swig_var_ExecInst_GO_ALONG_set);
  SWIG_addvarlink(globals, "ExecInst_OVER_THE_DAY", Swig_var_ExecInst_OVER_THE_DAY_get, Swig_var_ExecInst_OVER_THE_DAY_set);
  SWIG_addvarlink(globals, "ExecInst_HELD", Swig_var_ExecInst_HELD_get, Swig_var_ExecInst_HELD_set);
  SWIG_addvarlink(globals, "ExecInst_PARTICIPATE_DO_NOT_INITIATE", Swig_var_ExecInst_PARTICIPATE_DO_NOT_INITIATE_get, Swig_var_ExecInst_PARTICIPATE_DO_NOT_INITIATE_set);
  SWIG_addvarlink(globals, "ExecInst_STRICT_SCALE", Swig_var_ExecInst_STRICT_SCALE_get, Swig_var_ExecInst_STRICT_SCALE_set);
  SWIG_addvarlink(globals, "ExecInst_TRY_TO_SCALE", Swig_var_ExecInst_TRY_TO_SCALE_get, Swig_var_ExecInst_TRY_TO_SCALE_set);
  SWIG_addvarlink(globals, "ExecInst_STAY_ON_BID_SIDE", Swig_var_ExecInst_STAY_ON_BID_SIDE_get, Swig_var_ExecInst_STAY_ON_BID_SIDE_set);
  SWIG_addvarlink(globals, "ExecInst_NO_CROSS", Swig_var_ExecInst_NO_CROSS_get, Swig_var_ExecInst_NO_CROSS_set);
  SWIG_addvarlink(globals, "ExecInst_OK_TO_CROSS", Swig_var_ExecInst_OK_TO_CROSS_get, Swig_var_ExecInst_OK_TO_CROSS_set);
  SWIG_addvarlink(globals, "ExecInst_CALL_FIRST", Swig_var_ExecInst_CALL_FIRST_get, Swig_var_ExecInst_CALL_FIRST_set);
  SWIG_addvarlink(globals, "ExecInst_PERCENT_OF_VOLUME", Swig_var_ExecInst_PERCENT_OF_VOLUME_get, Swig_var_ExecInst_PERCENT_OF_VOLUME_set);
  SWIG_addvarlink(globals, "ExecInst_DO_NOT_INCREASE", Swig_var_ExecInst_DO_NOT_INCREASE_get, Swig_var_ExecInst_DO_NOT_INCREASE_set);
  SWIG_addvarlink(globals, "ExecInst_DO_NOT_REDUCE", Swig_var_ExecInst_DO_NOT_REDUCE_get, Swig_var_ExecInst_DO_NOT_REDUCE_set);
  SWIG_addvarlink(globals, "ExecInst_ALL_OR_NONE", Swig_var_ExecInst_ALL_OR_NONE_get, Swig_var_ExecInst_ALL_OR_NONE_set);
  SWIG_addvarlink(globals, "ExecInst_INSTITUTIONS_ONLY", Swig_var_ExecInst_INSTITUTIONS_ONLY_get, Swig_var_ExecInst_INSTITUTIONS_ONLY_set);
  SWIG_addvarlink(globals, "ExecInst_LAST_PEG", Swig_var_ExecInst_LAST_PEG_get, Swig_var_ExecInst_LAST_PEG_set);
  SWIG_addvarlink(globals, "ExecInst_MID_PRICE_PEG", Swig_var_ExecInst_MID_PRICE_PEG_get, Swig_var_ExecInst_MID_PRICE_PEG_set);
  SWIG_addvarlink(globals, "ExecInst_NON_NEGOTIABLE", Swig_var_ExecInst_NON_NEGOTIABLE_get, Swig_var_ExecInst_NON_NEGOTIABLE_set);
  SWIG_addvarlink(globals, "ExecInst_OPENING_PEG", Swig_var_ExecInst_OPENING_PEG_get, Swig_var_ExecInst_OPENING_PEG_set);
  SWIG_addvarlink(globals, "ExecInst_MARKET_PEG", Swig_var_ExecInst_MARKET_PEG_get, Swig_var_ExecInst_MARKET_PEG_set);
  SWIG_addvarlink(globals, "ExecInst_PRIMARY_PEG", Swig_var_ExecInst_PRIMARY_PEG_get, Swig_var_ExecInst_PRIMARY_PEG_set);
  SWIG_addvarlink(globals, "ExecInst_SUSPEND", Swig_var_ExecInst_SUSPEND_get, Swig_var_ExecInst_SUSPEND_set);
  SWIG_addvarlink(globals, "ExecInst_CUSTOMER_DISPLAY_INSTRUCTION", Swig_var_ExecInst_CUSTOMER_DISPLAY_INSTRUCTION_get, Swig_var_ExecInst_CUSTOMER_DISPLAY_INSTRUCTION_set);
  SWIG_addvarlink(globals, "ExecInst_NETTING", Swig_var_ExecInst_NETTING_get, Swig_var_ExecInst_NETTING_set);
  SWIG_addvarlink(globals, "ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER", Swig_var_ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get, Swig_var_ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_set);
  SWIG_addvarlink(globals, "ExecInst_PEG_TO_VWAP", Swig_var_ExecInst_PEG_TO_VWAP_get, Swig_var_ExecInst_PEG_TO_VWAP_set);
  SWIG_addvarlink(globals, "ExecInst_TRY_TO_STOP", Swig_var_ExecInst_TRY_TO_STOP_get, Swig_var_ExecInst_TRY_TO_STOP_set);
  SWIG_addvarlink(globals, "ExecInst_CANCEL_ON_SYSTEM_FAILURE", Swig_var_ExecInst_CANCEL_ON_SYSTEM_FAILURE_get, Swig_var_ExecInst_CANCEL_ON_SYSTEM_FAILURE_set);
  SWIG_addvarlink(globals, "ExecInst_TRADE_ALONG", Swig_var_ExecInst_TRADE_ALONG_get, Swig_var_ExecInst_TRADE_ALONG_set);
  SWIG_addvarlink(globals, "ExecInst_REINSTATE_ON_SYSTEM_FAILURE", Swig_var_ExecInst_REINSTATE_ON_SYSTEM_FAILURE_get, Swig_var_ExecInst_REINSTATE_ON_SYSTEM_FAILURE_set);
  SWIG_addvarlink(globals, "ExecInst_REINSTATE_ON_TRADING_HALT", Swig_var_ExecInst_REINSTATE_ON_TRADING_HALT_get, Swig_var_ExecInst_REINSTATE_ON_TRADING_HALT_set);
  SWIG_addvarlink(globals, "ExecInst_CANCEL_ON_TRADING_HALT", Swig_var_ExecInst_CANCEL_ON_TRADING_HALT_get, Swig_var_ExecInst_CANCEL_ON_TRADING_HALT_set);
  SWIG_addvarlink(globals, "ExecInst_CANCEL_IF_NOT_BEST", Swig_var_ExecInst_CANCEL_IF_NOT_BEST_get, Swig_var_ExecInst_CANCEL_IF_NOT_BEST_set);
  SWIG_addvarlink(globals, "ExecInst_TRAILING_STOP_PEG", Swig_var_ExecInst_TRAILING_STOP_PEG_get, Swig_var_ExecInst_TRAILING_STOP_PEG_set);
  SWIG_addvarlink(globals, "ExecInst_STRICT_LIMIT", Swig_var_ExecInst_STRICT_LIMIT_get, Swig_var_ExecInst_STRICT_LIMIT_set);
  SWIG_addvarlink(globals, "ExecInst_IGNORE_PRICE_VALIDITY_CHECKS", Swig_var_ExecInst_IGNORE_PRICE_VALIDITY_CHECKS_get, Swig_var_ExecInst_IGNORE_PRICE_VALIDITY_CHECKS_set);
  SWIG_addvarlink(globals, "ExecInst_PEG_TO_LIMIT_PRICE", Swig_var_ExecInst_PEG_TO_LIMIT_PRICE_get, Swig_var_ExecInst_PEG_TO_LIMIT_PRICE_set);
  SWIG_addvarlink(globals, "ExecInst_WORK_TO_TARGET_STRATEGY", Swig_var_ExecInst_WORK_TO_TARGET_STRATEGY_get, Swig_var_ExecInst_WORK_TO_TARGET_STRATEGY_set);
  SWIG_addvarlink(globals, "ExecInst_INTERMARKET_SWEEP", Swig_var_ExecInst_INTERMARKET_SWEEP_get, Swig_var_ExecInst_INTERMARKET_SWEEP_set);
  SWIG_addvarlink(globals, "ExecInst_EXTERNAL_ROUTING_ALLOWED", Swig_var_ExecInst_EXTERNAL_ROUTING_ALLOWED_get, Swig_var_ExecInst_EXTERNAL_ROUTING_ALLOWED_set);
  SWIG_addvarlink(globals, "ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED", Swig_var_ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED_get, Swig_var_ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED_set);
  SWIG_addvarlink(globals, "ExecInst_IMBALANCE_ONLY", Swig_var_ExecInst_IMBALANCE_ONLY_get, Swig_var_ExecInst_IMBALANCE_ONLY_set);
  SWIG_addvarlink(globals, "ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE", Swig_var_ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE_get, Swig_var_ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE_set);
  SWIG_addvarlink(globals, "ExecInst_BEST_EXECUTION", Swig_var_ExecInst_BEST_EXECUTION_get, Swig_var_ExecInst_BEST_EXECUTION_set);
  SWIG_addvarlink(globals, "ExecInst_SUSPEND_ON_SYSTEM_FAILURE", Swig_var_ExecInst_SUSPEND_ON_SYSTEM_FAILURE_get, Swig_var_ExecInst_SUSPEND_ON_SYSTEM_FAILURE_set);
  SWIG_addvarlink(globals, "ExecInst_SUSPEND_ON_TRADING_HALT", Swig_var_ExecInst_SUSPEND_ON_TRADING_HALT_get, Swig_var_ExecInst_SUSPEND_ON_TRADING_HALT_set);
  SWIG_addvarlink(globals, "ExecInst_REINSTATE_ON_CONNECTION_LOSS", Swig_var_ExecInst_REINSTATE_ON_CONNECTION_LOSS_get, Swig_var_ExecInst_REINSTATE_ON_CONNECTION_LOSS_set);
  SWIG_addvarlink(globals, "ExecInst_CANCEL_ON_CONNECTION_LOSS", Swig_var_ExecInst_CANCEL_ON_CONNECTION_LOSS_get, Swig_var_ExecInst_CANCEL_ON_CONNECTION_LOSS_set);
  SWIG_addvarlink(globals, "ExecInst_SUSPEND_ON_CONNECTION_LOSS", Swig_var_ExecInst_SUSPEND_ON_CONNECTION_LOSS_get, Swig_var_ExecInst_SUSPEND_ON_CONNECTION_LOSS_set);
  SWIG_addvarlink(globals, "ExecInst_RELEASE_FROM_SUSPENSION", Swig_var_ExecInst_RELEASE_FROM_SUSPENSION_get, Swig_var_ExecInst_RELEASE_FROM_SUSPENSION_set);
  SWIG_addvarlink(globals, "ExecInst_EXECUTE_AS_DELTA_NEUTRAL", Swig_var_ExecInst_EXECUTE_AS_DELTA_NEUTRAL_get, Swig_var_ExecInst_EXECUTE_AS_DELTA_NEUTRAL_set);
  SWIG_addvarlink(globals, "ExecInst_EXECUTE_AS_DURATION_NEUTRAL", Swig_var_ExecInst_EXECUTE_AS_DURATION_NEUTRAL_get, Swig_var_ExecInst_EXECUTE_AS_DURATION_NEUTRAL_set);
  SWIG_addvarlink(globals, "ExecInst_EXECUTE_AS_FX_NEUTRAL", Swig_var_ExecInst_EXECUTE_AS_FX_NEUTRAL_get, Swig_var_ExecInst_EXECUTE_AS_FX_NEUTRAL_set);
  SWIG_addvarlink(globals, "ExecInst_RELEASE", Swig_var_ExecInst_RELEASE_get, Swig_var_ExecInst_RELEASE_set);
  SWIG_addvarlink(globals, "ExecInst_MIN_GUARANTEED_FILL_ELIGIBLE", Swig_var_ExecInst_MIN_GUARANTEED_FILL_ELIGIBLE_get, Swig_var_ExecInst_MIN_GUARANTEED_FILL_ELIGIBLE_set);
  SWIG_addvarlink(globals, "ExecInst_BYPASS_NON_DISPLAY_LIQUIDITY", Swig_var_ExecInst_BYPASS_NON_DISPLAY_LIQUIDITY_get, Swig_var_ExecInst_BYPASS_NON_DISPLAY_LIQUIDITY_set);
  SWIG_addvarlink(globals, "ExecInst_LOCK", Swig_var_ExecInst_LOCK_get, Swig_var_ExecInst_LOCK_set);
  SWIG_addvarlink(globals, "ExecInst_IGNORE_NOTIONAL_VALUE_CHECKS", Swig_var_ExecInst_IGNORE_NOTIONAL_VALUE_CHECKS_get, Swig_var_ExecInst_IGNORE_NOTIONAL_VALUE_CHECKS_set);
  SWIG_addvarlink(globals, "ExecInst_TRD_AT_REF_PX", Swig_var_ExecInst_TRD_AT_REF_PX_get, Swig_var_ExecInst_TRD_AT_REF_PX_set);
  SWIG_addvarlink(globals, "ExecInst_ALLOW_FACILITATION", Swig_var_ExecInst_ALLOW_FACILITATION_get, Swig_var_ExecInst_ALLOW_FACILITATION_set);
  SWIG_addvarlink(globals, "ExecTransType_NEW", Swig_var_ExecTransType_NEW_get, Swig_var_ExecTransType_NEW_set);
  SWIG_addvarlink(globals, "ExecTransType_CANCEL", Swig_var_ExecTransType_CANCEL_get, Swig_var_ExecTransType_CANCEL_set);
  SWIG_addvarlink(globals, "ExecTransType_CORRECT", Swig_var_ExecTransType_CORRECT_get, Swig_var_ExecTransType_CORRECT_set);
  SWIG_addvarlink(globals, "ExecTransType_STATUS", Swig_var_ExecTransType_STATUS_get, Swig_var_ExecTransType_STATUS_set);
  SWIG_addvarlink(globals, "HandlInst_AUTOMATED_EXECUTION_NO_INTERVENTION", Swig_var_HandlInst_AUTOMATED_EXECUTION_NO_INTERVENTION_get, Swig_var_HandlInst_AUTOMATED_EXECUTION_NO_INTERVENTION_set);
  SWIG_addvarlink(globals, "HandlInst_AUTOMATED_EXECUTION_INTERVENTION_OK", Swig_var_HandlInst_AUTOMATED_EXECUTION_INTERVENTION_OK_get, Swig_var_HandlInst_AUTOMATED_EXECUTION_INTERVENTION_OK_set);
  SWIG_addvarlink(globals, "HandlInst_MANUAL_ORDER", Swig_var_HandlInst_MANUAL_ORDER_get, Swig_var_HandlInst_MANUAL_ORDER_set);
  SWIG_addvarlink(globals, "IDSource_CUSIP", Swig_var_IDSource_CUSIP_get, Swig_var_IDSource_CUSIP_set);
  SWIG_addvarlink(globals, "IDSource_SEDOL", Swig_var_IDSource_SEDOL_get, Swig_var_IDSource_SEDOL_set);
  SWIG_addvarlink(globals, "IDSource_QUIK", Swig_var_IDSource_QUIK_get, Swig_var_IDSource_QUIK_set);
  SWIG_addvarlink(globals, "IDSource_ISIN_NUMBER", Swig_var_IDSource_ISIN_NUMBER_get, Swig_var_IDSource_ISIN_NUMBER_set);
  SWIG_addvarlink(globals, "IDSource_RIC_CODE", Swig_var_IDSource_RIC_CODE_get, Swig_var_IDSource_RIC_CODE_set);
  SWIG_addvarlink(globals, "IDSource_ISO_CURRENCY_CODE", Swig_var_IDSource_ISO_CURRENCY_CODE_get, Swig_var_IDSource_ISO_CURRENCY_CODE_set);
  SWIG_addvarlink(globals, "IDSource_ISO_COUNTRY_CODE", Swig_var_IDSource_ISO_COUNTRY_CODE_get, Swig_var_IDSource_ISO_COUNTRY_CODE_set);
  SWIG_addvarlink(globals, "IDSource_EXCHANGE_SYMBOL", Swig_var_IDSource_EXCHANGE_SYMBOL_get, Swig_var_IDSource_EXCHANGE_SYMBOL_set);
  SWIG_addvarlink(globals, "IDSource_CONSOLIDATED_TAPE_ASSOCIATION", Swig_var_IDSource_CONSOLIDATED_TAPE_ASSOCIATION_get, Swig_var_IDSource_CONSOLIDATED_TAPE_ASSOCIATION_set);
  SWIG_addvarlink(globals, "IOIOthSvc_AUTEX", Swig_var_IOIOthSvc_AUTEX_get, Swig_var_IOIOthSvc_AUTEX_set);
  SWIG_addvarlink(globals, "IOIOthSvc_BRIDGE", Swig_var_IOIOthSvc_BRIDGE_get, Swig_var_IOIOthSvc_BRIDGE_set);
  SWIG_addvarlink(globals, "IOIQltyInd_HIGH", Swig_var_IOIQltyInd_HIGH_get, Swig_var_IOIQltyInd_HIGH_set);
  SWIG_addvarlink(globals, "IOIQltyInd_LOW", Swig_var_IOIQltyInd_LOW_get, Swig_var_IOIQltyInd_LOW_set);
  SWIG_addvarlink(globals, "IOIQltyInd_MEDIUM", Swig_var_IOIQltyInd_MEDIUM_get, Swig_var_IOIQltyInd_MEDIUM_set);
  SWIG_addvarlink(globals, "IOIShares_LARGE", Swig_var_IOIShares_LARGE_get, Swig_var_IOIShares_LARGE_set);
  SWIG_addvarlink(globals, "IOIShares_MEDIUM", Swig_var_IOIShares_MEDIUM_get, Swig_var_IOIShares_MEDIUM_set);
  SWIG_addvarlink(globals, "IOIShares_SMALL", Swig_var_IOIShares_SMALL_get, Swig_var_IOIShares_SMALL_set);
  SWIG_addvarlink(globals, "IOITransType_CANCEL", Swig_var_IOITransType_CANCEL_get, Swig_var_IOITransType_CANCEL_set);
  SWIG_addvarlink(globals, "IOITransType_NEW", Swig_var_IOITransType_NEW_get, Swig_var_IOITransType_NEW_set);
  SWIG_addvarlink(globals, "IOITransType_REPLACE", Swig_var_IOITransType_REPLACE_get, Swig_var_IOITransType_REPLACE_set);
  SWIG_addvarlink(globals, "LastCapacity_AGENT", Swig_var_LastCapacity_AGENT_get, Swig_var_LastCapacity_AGENT_set);
  SWIG_addvarlink(globals, "LastCapacity_CROSS_AS_AGENT", Swig_var_LastCapacity_CROSS_AS_AGENT_get, Swig_var_LastCapacity_CROSS_AS_AGENT_set);
  SWIG_addvarlink(globals, "LastCapacity_CROSS_AS_PRINCIPAL", Swig_var_LastCapacity_CROSS_AS_PRINCIPAL_get, Swig_var_LastCapacity_CROSS_AS_PRINCIPAL_set);
  SWIG_addvarlink(globals, "LastCapacity_PRINCIPAL", Swig_var_LastCapacity_PRINCIPAL_get, Swig_var_LastCapacity_PRINCIPAL_set);
  SWIG_addvarlink(globals, "LastCapacity_RISKLESS_PRINCIPAL", Swig_var_LastCapacity_RISKLESS_PRINCIPAL_get, Swig_var_LastCapacity_RISKLESS_PRINCIPAL_set);
  SWIG_addvarlink(globals, "OrdStatus_NEW", Swig_var_OrdStatus_NEW_get, Swig_var_OrdStatus_NEW_set);
  SWIG_addvarlink(globals, "OrdStatus_PARTIALLY_FILLED", Swig_var_OrdStatus_PARTIALLY_FILLED_get, Swig_var_OrdStatus_PARTIALLY_FILLED_set);
  SWIG_addvarlink(globals, "OrdStatus_FILLED", Swig_var_OrdStatus_FILLED_get, Swig_var_OrdStatus_FILLED_set);
  SWIG_addvarlink(globals, "OrdStatus_DONE_FOR_DAY", Swig_var_OrdStatus_DONE_FOR_DAY_get, Swig_var_OrdStatus_DONE_FOR_DAY_set);
  SWIG_addvarlink(globals, "OrdStatus_CANCELED", Swig_var_OrdStatus_CANCELED_get, Swig_var_OrdStatus_CANCELED_set);
  SWIG_addvarlink(globals, "OrdStatus_REPLACED", Swig_var_OrdStatus_REPLACED_get, Swig_var_OrdStatus_REPLACED_set);
  SWIG_addvarlink(globals, "OrdStatus_PENDING_CANCEL", Swig_var_OrdStatus_PENDING_CANCEL_get, Swig_var_OrdStatus_PENDING_CANCEL_set);
  SWIG_addvarlink(globals, "OrdStatus_STOPPED", Swig_var_OrdStatus_STOPPED_get, Swig_var_OrdStatus_STOPPED_set);
  SWIG_addvarlink(globals, "OrdStatus_REJECTED", Swig_var_OrdStatus_REJECTED_get, Swig_var_OrdStatus_REJECTED_set);
  SWIG_addvarlink(globals, "OrdStatus_SUSPENDED", Swig_var_OrdStatus_SUSPENDED_get, Swig_var_OrdStatus_SUSPENDED_set);
  SWIG_addvarlink(globals, "OrdStatus_PENDING_NEW", Swig_var_OrdStatus_PENDING_NEW_get, Swig_var_OrdStatus_PENDING_NEW_set);
  SWIG_addvarlink(globals, "OrdStatus_CALCULATED", Swig_var_OrdStatus_CALCULATED_get, Swig_var_OrdStatus_CALCULATED_set);
  SWIG_addvarlink(globals, "OrdStatus_EXPIRED", Swig_var_OrdStatus_EXPIRED_get, Swig_var_OrdStatus_EXPIRED_set);
  SWIG_addvarlink(globals, "OrdStatus_ACCEPTED_FOR_BIDDING", Swig_var_OrdStatus_ACCEPTED_FOR_BIDDING_get, Swig_var_OrdStatus_ACCEPTED_FOR_BIDDING_set);
  SWIG_addvarlink(globals, "OrdStatus_PENDING_REPLACE", Swig_var_OrdStatus_PENDING_REPLACE_get, Swig_var_OrdStatus_PENDING_REPLACE_set);
  SWIG_addvarlink(globals, "OrdType_MARKET", Swig_var_OrdType_MARKET_get, Swig_var_OrdType_MARKET_set);
  SWIG_addvarlink(globals, "OrdType_LIMIT", Swig_var_OrdType_LIMIT_get, Swig_var_OrdType_LIMIT_set);
  SWIG_addvarlink(globals, "OrdType_STOP", Swig_var_OrdType_STOP_get, Swig_var_OrdType_STOP_set);
  SWIG_addvarlink(globals, "OrdType_STOP_LIMIT", Swig_var_OrdType_STOP_LIMIT_get, Swig_var_OrdType_STOP_LIMIT_set);
  SWIG_addvarlink(globals, "OrdType_MARKET_ON_CLOSE", Swig_var_OrdType_MARKET_ON_CLOSE_get, Swig_var_OrdType_MARKET_ON_CLOSE_set);
  SWIG_addvarlink(globals, "OrdType_WITH_OR_WITHOUT", Swig_var_OrdType_WITH_OR_WITHOUT_get, Swig_var_OrdType_WITH_OR_WITHOUT_set);
  SWIG_addvarlink(globals, "OrdType_LIMIT_OR_BETTER", Swig_var_OrdType_LIMIT_OR_BETTER_get, Swig_var_OrdType_LIMIT_OR_BETTER_set);
  SWIG_addvarlink(globals, "OrdType_LIMIT_WITH_OR_WITHOUT", Swig_var_OrdType_LIMIT_WITH_OR_WITHOUT_get, Swig_var_OrdType_LIMIT_WITH_OR_WITHOUT_set);
  SWIG_addvarlink(globals, "OrdType_ON_BASIS", Swig_var_OrdType_ON_BASIS_get, Swig_var_OrdType_ON_BASIS_set);
  SWIG_addvarlink(globals, "OrdType_ON_CLOSE", Swig_var_OrdType_ON_CLOSE_get, Swig_var_OrdType_ON_CLOSE_set);
  SWIG_addvarlink(globals, "OrdType_LIMIT_ON_CLOSE", Swig_var_OrdType_LIMIT_ON_CLOSE_get, Swig_var_OrdType_LIMIT_ON_CLOSE_set);
  SWIG_addvarlink(globals, "OrdType_FOREX_MARKET", Swig_var_OrdType_FOREX_MARKET_get, Swig_var_OrdType_FOREX_MARKET_set);
  SWIG_addvarlink(globals, "OrdType_PREVIOUSLY_QUOTED", Swig_var_OrdType_PREVIOUSLY_QUOTED_get, Swig_var_OrdType_PREVIOUSLY_QUOTED_set);
  SWIG_addvarlink(globals, "OrdType_PREVIOUSLY_INDICATED", Swig_var_OrdType_PREVIOUSLY_INDICATED_get, Swig_var_OrdType_PREVIOUSLY_INDICATED_set);
  SWIG_addvarlink(globals, "OrdType_PEGGED", Swig_var_OrdType_PEGGED_get, Swig_var_OrdType_PEGGED_set);
  SWIG_addvarlink(globals, "OrdType_FOREX_LIMIT", Swig_var_OrdType_FOREX_LIMIT_get, Swig_var_OrdType_FOREX_LIMIT_set);
  SWIG_addvarlink(globals, "OrdType_FOREX_SWAP", Swig_var_OrdType_FOREX_SWAP_get, Swig_var_OrdType_FOREX_SWAP_set);
  SWIG_addvarlink(globals, "OrdType_FOREX_PREVIOUSLY_QUOTED", Swig_var_OrdType_FOREX_PREVIOUSLY_QUOTED_get, Swig_var_OrdType_FOREX_PREVIOUSLY_QUOTED_set);
  SWIG_addvarlink(globals, "OrdType_FUNARI", Swig_var_OrdType_FUNARI_get, Swig_var_OrdType_FUNARI_set);
  SWIG_addvarlink(globals, "OrdType_MARKET_IF_TOUCHED", Swig_var_OrdType_MARKET_IF_TOUCHED_get, Swig_var_OrdType_MARKET_IF_TOUCHED_set);
  SWIG_addvarlink(globals, "OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT", Swig_var_OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT_get, Swig_var_OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT_set);
  SWIG_addvarlink(globals, "OrdType_PREVIOUS_FUND_VALUATION_POINT", Swig_var_OrdType_PREVIOUS_FUND_VALUATION_POINT_get, Swig_var_OrdType_PREVIOUS_FUND_VALUATION_POINT_set);
  SWIG_addvarlink(globals, "OrdType_NEXT_FUND_VALUATION_POINT", Swig_var_OrdType_NEXT_FUND_VALUATION_POINT_get, Swig_var_OrdType_NEXT_FUND_VALUATION_POINT_set);
  SWIG_addvarlink(globals, "OrdType_COUNTER_ORDER_SELECTION", Swig_var_OrdType_COUNTER_ORDER_SELECTION_get, Swig_var_OrdType_COUNTER_ORDER_SELECTION_set);
  SWIG_addvarlink(globals, "OrdType_STOP_ON_BID_OR_OFFER", Swig_var_OrdType_STOP_ON_BID_OR_OFFER_get, Swig_var_OrdType_STOP_ON_BID_OR_OFFER_set);
  SWIG_addvarlink(globals, "OrdType_STOP_LIMIT_ON_BID_OR_OFFER", Swig_var_OrdType_STOP_LIMIT_ON_BID_OR_OFFER_get, Swig_var_OrdType_STOP_LIMIT_ON_BID_OR_OFFER_set);
  SWIG_addvarlink(globals, "Rule80A_AGENCY_SINGLE_ORDER", Swig_var_Rule80A_AGENCY_SINGLE_ORDER_get, Swig_var_Rule80A_AGENCY_SINGLE_ORDER_set);
  SWIG_addvarlink(globals, "Rule80A_PROPRIETARY_NON_ALGO", Swig_var_Rule80A_PROPRIETARY_NON_ALGO_get, Swig_var_Rule80A_PROPRIETARY_NON_ALGO_set);
  SWIG_addvarlink(globals, "Rule80A_PROGRAM_ORDER_MEMBER", Swig_var_Rule80A_PROGRAM_ORDER_MEMBER_get, Swig_var_Rule80A_PROGRAM_ORDER_MEMBER_set);
  SWIG_addvarlink(globals, "Rule80A_INDIVIDUAL_INVESTOR", Swig_var_Rule80A_INDIVIDUAL_INVESTOR_get, Swig_var_Rule80A_INDIVIDUAL_INVESTOR_set);
  SWIG_addvarlink(globals, "Rule80A_PROPRIETARY_ALGO", Swig_var_Rule80A_PROPRIETARY_ALGO_get, Swig_var_Rule80A_PROPRIETARY_ALGO_set);
  SWIG_addvarlink(globals, "Rule80A_AGENCY_ALGO", Swig_var_Rule80A_AGENCY_ALGO_get, Swig_var_Rule80A_AGENCY_ALGO_set);
  SWIG_addvarlink(globals, "Rule80A_PROGRAM_ORDER_OTHER_MEMBER", Swig_var_Rule80A_PROGRAM_ORDER_OTHER_MEMBER_get, Swig_var_Rule80A_PROGRAM_ORDER_OTHER_MEMBER_set);
  SWIG_addvarlink(globals, "Rule80A_AGENT_FOR_OTHER_MEMBER", Swig_var_Rule80A_AGENT_FOR_OTHER_MEMBER_get, Swig_var_Rule80A_AGENT_FOR_OTHER_MEMBER_set);
  SWIG_addvarlink(globals, "Rule80A_AGENCY_INDEX_ARB", Swig_var_Rule80A_AGENCY_INDEX_ARB_get, Swig_var_Rule80A_AGENCY_INDEX_ARB_set);
  SWIG_addvarlink(globals, "Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER", Swig_var_Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER_get, Swig_var_Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER_set);
  SWIG_addvarlink(globals, "Rule80A_AGENCY_NON_ALGO", Swig_var_Rule80A_AGENCY_NON_ALGO_get, Swig_var_Rule80A_AGENCY_NON_ALGO_set);
  SWIG_addvarlink(globals, "Rule80A_SHORT_EXEMPT_TRANSACTION_A_TYPE", Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_A_TYPE_get, Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_A_TYPE_set);
  SWIG_addvarlink(globals, "Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL", Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL_get, Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL_set);
  SWIG_addvarlink(globals, "Rule80A_SHORT_EXEMPT_TRANSACTION_W_TYPE", Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_W_TYPE_get, Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_W_TYPE_set);
  SWIG_addvarlink(globals, "Rule80A_SHORT_EXEMPT_TRANSACTION_I_TYPE", Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_I_TYPE_get, Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_I_TYPE_set);
  SWIG_addvarlink(globals, "Rule80A_SHORT_EXEMPT_TRANSACTION_MEMBER_AFFLIATED", Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_MEMBER_AFFLIATED_get, Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_MEMBER_AFFLIATED_set);
  SWIG_addvarlink(globals, "Rule80A_PROPRIETARY_TRANSACTION_AFFILIATED", Swig_var_Rule80A_PROPRIETARY_TRANSACTION_AFFILIATED_get, Swig_var_Rule80A_PROPRIETARY_TRANSACTION_AFFILIATED_set);
  SWIG_addvarlink(globals, "Rule80A_PRINCIPAL", Swig_var_Rule80A_PRINCIPAL_get, Swig_var_Rule80A_PRINCIPAL_set);
  SWIG_addvarlink(globals, "Rule80A_TRANSACTION_NON_MEMBER", Swig_var_Rule80A_TRANSACTION_NON_MEMBER_get, Swig_var_Rule80A_TRANSACTION_NON_MEMBER_set);
  SWIG_addvarlink(globals, "Rule80A_SPECIALIST_TRADES", Swig_var_Rule80A_SPECIALIST_TRADES_get, Swig_var_Rule80A_SPECIALIST_TRADES_set);
  SWIG_addvarlink(globals, "Rule80A_TRANSACTION_UNAFFILIATED_MEMBER", Swig_var_Rule80A_TRANSACTION_UNAFFILIATED_MEMBER_get, Swig_var_Rule80A_TRANSACTION_UNAFFILIATED_MEMBER_set);
  SWIG_addvarlink(globals, "Rule80A_SHORT_EXEMPT_TRANSACTION_MEMBER_NOT_AFFLIATED", Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_MEMBER_NOT_AFFLIATED_get, Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_MEMBER_NOT_AFFLIATED_set);
  SWIG_addvarlink(globals, "Rule80A_SHORT_EXEMPT_TRANSACTION_NON_MEMBER", Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_NON_MEMBER_get, Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_NON_MEMBER_set);
  SWIG_addvarlink(globals, "Side_BUY", Swig_var_Side_BUY_get, Swig_var_Side_BUY_set);
  SWIG_addvarlink(globals, "Side_SELL", Swig_var_Side_SELL_get, Swig_var_Side_SELL_set);
  SWIG_addvarlink(globals, "Side_BUY_MINUS", Swig_var_Side_BUY_MINUS_get, Swig_var_Side_BUY_MINUS_set);
  SWIG_addvarlink(globals, "Side_SELL_PLUS", Swig_var_Side_SELL_PLUS_get, Swig_var_Side_SELL_PLUS_set);
  SWIG_addvarlink(globals, "Side_SELL_SHORT", Swig_var_Side_SELL_SHORT_get, Swig_var_Side_SELL_SHORT_set);
  SWIG_addvarlink(globals, "Side_SELL_SHORT_EXEMPT", Swig_var_Side_SELL_SHORT_EXEMPT_get, Swig_var_Side_SELL_SHORT_EXEMPT_set);
  SWIG_addvarlink(globals, "Side_UNDISCLOSED", Swig_var_Side_UNDISCLOSED_get, Swig_var_Side_UNDISCLOSED_set);
  SWIG_addvarlink(globals, "Side_CROSS", Swig_var_Side_CROSS_get, Swig_var_Side_CROSS_set);
  SWIG_addvarlink(globals, "Side_CROSS_SHORT", Swig_var_Side_CROSS_SHORT_get, Swig_var_Side_CROSS_SHORT_set);
  SWIG_addvarlink(globals, "Side_AS_DEFINED", Swig_var_Side_AS_DEFINED_get, Swig_var_Side_AS_DEFINED_set);
  SWIG_addvarlink(globals, "Side_OPPOSITE", Swig_var_Side_OPPOSITE_get, Swig_var_Side_OPPOSITE_set);
  SWIG_addvarlink(globals, "Side_CROSS_SHORT_EXEMPT", Swig_var_Side_CROSS_SHORT_EXEMPT_get, Swig_var_Side_CROSS_SHORT_EXEMPT_set);
  SWIG_addvarlink(globals, "Side_SUBSCRIBE", Swig_var_Side_SUBSCRIBE_get, Swig_var_Side_SUBSCRIBE_set);
  SWIG_addvarlink(globals, "Side_REDEEM", Swig_var_Side_REDEEM_get, Swig_var_Side_REDEEM_set);
  SWIG_addvarlink(globals, "Side_LEND", Swig_var_Side_LEND_get, Swig_var_Side_LEND_set);
  SWIG_addvarlink(globals, "Side_BORROW", Swig_var_Side_BORROW_get, Swig_var_Side_BORROW_set);
  SWIG_addvarlink(globals, "Side_SELL_UNDISCLOSED", Swig_var_Side_SELL_UNDISCLOSED_get, Swig_var_Side_SELL_UNDISCLOSED_set);
  SWIG_addvarlink(globals, "TimeInForce_DAY", Swig_var_TimeInForce_DAY_get, Swig_var_TimeInForce_DAY_set);
  SWIG_addvarlink(globals, "TimeInForce_GOOD_TILL_CANCEL", Swig_var_TimeInForce_GOOD_TILL_CANCEL_get, Swig_var_TimeInForce_GOOD_TILL_CANCEL_set);
  SWIG_addvarlink(globals, "TimeInForce_AT_THE_OPENING", Swig_var_TimeInForce_AT_THE_OPENING_get, Swig_var_TimeInForce_AT_THE_OPENING_set);
  SWIG_addvarlink(globals, "TimeInForce_IMMEDIATE_OR_CANCEL", Swig_var_TimeInForce_IMMEDIATE_OR_CANCEL_get, Swig_var_TimeInForce_IMMEDIATE_OR_CANCEL_set);
  SWIG_addvarlink(globals, "TimeInForce_FILL_OR_KILL", Swig_var_TimeInForce_FILL_OR_KILL_get, Swig_var_TimeInForce_FILL_OR_KILL_set);
  SWIG_addvarlink(globals, "TimeInForce_GOOD_TILL_CROSSING", Swig_var_TimeInForce_GOOD_TILL_CROSSING_get, Swig_var_TimeInForce_GOOD_TILL_CROSSING_set);
  SWIG_addvarlink(globals, "TimeInForce_GOOD_TILL_DATE", Swig_var_TimeInForce_GOOD_TILL_DATE_get, Swig_var_TimeInForce_GOOD_TILL_DATE_set);
  SWIG_addvarlink(globals, "TimeInForce_AT_THE_CLOSE", Swig_var_TimeInForce_AT_THE_CLOSE_get, Swig_var_TimeInForce_AT_THE_CLOSE_set);
  SWIG_addvarlink(globals, "TimeInForce_GOOD_THROUGH_CROSSING", Swig_var_TimeInForce_GOOD_THROUGH_CROSSING_get, Swig_var_TimeInForce_GOOD_THROUGH_CROSSING_set);
  SWIG_addvarlink(globals, "TimeInForce_AT_CROSSING", Swig_var_TimeInForce_AT_CROSSING_get, Swig_var_TimeInForce_AT_CROSSING_set);
  SWIG_addvarlink(globals, "TimeInForce_GOOD_FOR_TIME", Swig_var_TimeInForce_GOOD_FOR_TIME_get, Swig_var_TimeInForce_GOOD_FOR_TIME_set);
  SWIG_addvarlink(globals, "TimeInForce_GOOD_FOR_AUCTION", Swig_var_TimeInForce_GOOD_FOR_AUCTION_get, Swig_var_TimeInForce_GOOD_FOR_AUCTION_set);
  SWIG_addvarlink(globals, "TimeInForce_GOOD_FOR_MONTH", Swig_var_TimeInForce_GOOD_FOR_MONTH_get, Swig_var_TimeInForce_GOOD_FOR_MONTH_set);
  SWIG_addvarlink(globals, "Urgency_NORMAL", Swig_var_Urgency_NORMAL_get, Swig_var_Urgency_NORMAL_set);
  SWIG_addvarlink(globals, "Urgency_FLASH", Swig_var_Urgency_FLASH_get, Swig_var_Urgency_FLASH_set);
  SWIG_addvarlink(globals, "Urgency_BACKGROUND", Swig_var_Urgency_BACKGROUND_get, Swig_var_Urgency_BACKGROUND_set);
  SWIG_addvarlink(globals, "SettlmntTyp_REGULAR", Swig_var_SettlmntTyp_REGULAR_get, Swig_var_SettlmntTyp_REGULAR_set);
  SWIG_addvarlink(globals, "SettlmntTyp_CASH", Swig_var_SettlmntTyp_CASH_get, Swig_var_SettlmntTyp_CASH_set);
  SWIG_addvarlink(globals, "SettlmntTyp_NEXT_DAY", Swig_var_SettlmntTyp_NEXT_DAY_get, Swig_var_SettlmntTyp_NEXT_DAY_set);
  SWIG_addvarlink(globals, "SettlmntTyp_T_PLUS2", Swig_var_SettlmntTyp_T_PLUS2_get, Swig_var_SettlmntTyp_T_PLUS2_set);
  SWIG_addvarlink(globals, "SettlmntTyp_T_PLUS3", Swig_var_SettlmntTyp_T_PLUS3_get, Swig_var_SettlmntTyp_T_PLUS3_set);
  SWIG_addvarlink(globals, "SettlmntTyp_T_PLUS4", Swig_var_SettlmntTyp_T_PLUS4_get, Swig_var_SettlmntTyp_T_PLUS4_set);
  SWIG_addvarlink(globals, "SettlmntTyp_FUTURE", Swig_var_SettlmntTyp_FUTURE_get, Swig_var_SettlmntTyp_FUTURE_set);
  SWIG_addvarlink(globals, "SettlmntTyp_WHEN_AND_IF_ISSUED", Swig_var_SettlmntTyp_WHEN_AND_IF_ISSUED_get, Swig_var_SettlmntTyp_WHEN_AND_IF_ISSUED_set);
  SWIG_addvarlink(globals, "SettlmntTyp_SELLERS_OPTION", Swig_var_SettlmntTyp_SELLERS_OPTION_get, Swig_var_SettlmntTyp_SELLERS_OPTION_set);
  SWIG_addvarlink(globals, "SettlmntTyp_T_PLUS5", Swig_var_SettlmntTyp_T_PLUS5_get, Swig_var_SettlmntTyp_T_PLUS5_set);
  SWIG_addvarlink(globals, "SettlmntTyp_T1", Swig_var_SettlmntTyp_T1_get, Swig_var_SettlmntTyp_T1_set);
  SWIG_addvarlink(globals, "SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST", Swig_var_SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_get, Swig_var_SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_set);
  SWIG_addvarlink(globals, "SymbolSfx_WHEN_ISSUED", Swig_var_SymbolSfx_WHEN_ISSUED_get, Swig_var_SymbolSfx_WHEN_ISSUED_set);
  SWIG_addvarlink(globals, "AllocTransType_NEW", Swig_var_AllocTransType_NEW_get, Swig_var_AllocTransType_NEW_set);
  SWIG_addvarlink(globals, "AllocTransType_REPLACE", Swig_var_AllocTransType_REPLACE_get, Swig_var_AllocTransType_REPLACE_set);
  SWIG_addvarlink(globals, "AllocTransType_CANCEL", Swig_var_AllocTransType_CANCEL_get, Swig_var_AllocTransType_CANCEL_set);
  SWIG_addvarlink(globals, "AllocTransType_PRELIMINARY", Swig_var_AllocTransType_PRELIMINARY_get, Swig_var_AllocTransType_PRELIMINARY_set);
  SWIG_addvarlink(globals, "AllocTransType_CALCULATED", Swig_var_AllocTransType_CALCULATED_get, Swig_var_AllocTransType_CALCULATED_set);
  SWIG_addvarlink(globals, "AllocTransType_CALCULATED_WITHOUT_PRELIMINARY", Swig_var_AllocTransType_CALCULATED_WITHOUT_PRELIMINARY_get, Swig_var_AllocTransType_CALCULATED_WITHOUT_PRELIMINARY_set);
  SWIG_addvarlink(globals, "AllocTransType_REVERSAL", Swig_var_AllocTransType_REVERSAL_get, Swig_var_AllocTransType_REVERSAL_set);
  SWIG_addvarlink(globals, "OpenClose_CLOSE", Swig_var_OpenClose_CLOSE_get, Swig_var_OpenClose_CLOSE_set);
  SWIG_addvarlink(globals, "OpenClose_OPEN", Swig_var_OpenClose_OPEN_get, Swig_var_OpenClose_OPEN_set);
  SWIG_addvarlink(globals, "ProcessCode_REGULAR", Swig_var_ProcessCode_REGULAR_get, Swig_var_ProcessCode_REGULAR_set);
  SWIG_addvarlink(globals, "ProcessCode_SOFT_DOLLAR", Swig_var_ProcessCode_SOFT_DOLLAR_get, Swig_var_ProcessCode_SOFT_DOLLAR_set);
  SWIG_addvarlink(globals, "ProcessCode_STEP_IN", Swig_var_ProcessCode_STEP_IN_get, Swig_var_ProcessCode_STEP_IN_set);
  SWIG_addvarlink(globals, "ProcessCode_STEP_OUT", Swig_var_ProcessCode_STEP_OUT_get, Swig_var_ProcessCode_STEP_OUT_set);
  SWIG_addvarlink(globals, "ProcessCode_SOFT_DOLLAR_STEP_IN", Swig_var_ProcessCode_SOFT_DOLLAR_STEP_IN_get, Swig_var_ProcessCode_SOFT_DOLLAR_STEP_IN_set);
  SWIG_addvarlink(globals, "ProcessCode_SOFT_DOLLAR_STEP_OUT", Swig_var_ProcessCode_SOFT_DOLLAR_STEP_OUT_get, Swig_var_ProcessCode_SOFT_DOLLAR_STEP_OUT_set);
  SWIG_addvarlink(globals, "ProcessCode_PLAN_SPONSOR", Swig_var_ProcessCode_PLAN_SPONSOR_get, Swig_var_ProcessCode_PLAN_SPONSOR_set);
  SWIG_addvarlink(globals, "AllocStatus_ACCEPTED", Swig_var_AllocStatus_ACCEPTED_get, Swig_var_AllocStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "AllocStatus_BLOCK_LEVEL_REJECT", Swig_var_AllocStatus_BLOCK_LEVEL_REJECT_get, Swig_var_AllocStatus_BLOCK_LEVEL_REJECT_set);
  SWIG_addvarlink(globals, "AllocStatus_ACCOUNT_LEVEL_REJECT", Swig_var_AllocStatus_ACCOUNT_LEVEL_REJECT_get, Swig_var_AllocStatus_ACCOUNT_LEVEL_REJECT_set);
  SWIG_addvarlink(globals, "AllocStatus_RECEIVED", Swig_var_AllocStatus_RECEIVED_get, Swig_var_AllocStatus_RECEIVED_set);
  SWIG_addvarlink(globals, "AllocStatus_INCOMPLETE", Swig_var_AllocStatus_INCOMPLETE_get, Swig_var_AllocStatus_INCOMPLETE_set);
  SWIG_addvarlink(globals, "AllocStatus_REJECTED_BY_INTERMEDIARY", Swig_var_AllocStatus_REJECTED_BY_INTERMEDIARY_get, Swig_var_AllocStatus_REJECTED_BY_INTERMEDIARY_set);
  SWIG_addvarlink(globals, "AllocStatus_ALLOCATION_PENDING", Swig_var_AllocStatus_ALLOCATION_PENDING_get, Swig_var_AllocStatus_ALLOCATION_PENDING_set);
  SWIG_addvarlink(globals, "AllocStatus_REVERSED", Swig_var_AllocStatus_REVERSED_get, Swig_var_AllocStatus_REVERSED_set);
  SWIG_addvarlink(globals, "AllocStatus_CANCELLED_BY_INTERMEDIARY", Swig_var_AllocStatus_CANCELLED_BY_INTERMEDIARY_get, Swig_var_AllocStatus_CANCELLED_BY_INTERMEDIARY_set);
  SWIG_addvarlink(globals, "AllocStatus_CLAIMED", Swig_var_AllocStatus_CLAIMED_get, Swig_var_AllocStatus_CLAIMED_set);
  SWIG_addvarlink(globals, "AllocStatus_REFUSED", Swig_var_AllocStatus_REFUSED_get, Swig_var_AllocStatus_REFUSED_set);
  SWIG_addvarlink(globals, "AllocStatus_PENDING_GIVE_UP_APPROVAL", Swig_var_AllocStatus_PENDING_GIVE_UP_APPROVAL_get, Swig_var_AllocStatus_PENDING_GIVE_UP_APPROVAL_set);
  SWIG_addvarlink(globals, "AllocStatus_CANCELLED", Swig_var_AllocStatus_CANCELLED_get, Swig_var_AllocStatus_CANCELLED_set);
  SWIG_addvarlink(globals, "AllocStatus_PENDING_TAKE_UP_APPROVAL", Swig_var_AllocStatus_PENDING_TAKE_UP_APPROVAL_get, Swig_var_AllocStatus_PENDING_TAKE_UP_APPROVAL_set);
  SWIG_addvarlink(globals, "AllocStatus_REVERSAL_PENDING", Swig_var_AllocStatus_REVERSAL_PENDING_get, Swig_var_AllocStatus_REVERSAL_PENDING_set);
  SWIG_addvarlink(globals, "AllocRejCode_UNKNOWN_ACCOUNT", Swig_var_AllocRejCode_UNKNOWN_ACCOUNT_get, Swig_var_AllocRejCode_UNKNOWN_ACCOUNT_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_QUANTITY", Swig_var_AllocRejCode_INCORRECT_QUANTITY_get, Swig_var_AllocRejCode_INCORRECT_QUANTITY_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_AVERAGEG_PRICE", Swig_var_AllocRejCode_INCORRECT_AVERAGEG_PRICE_get, Swig_var_AllocRejCode_INCORRECT_AVERAGEG_PRICE_set);
  SWIG_addvarlink(globals, "AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC", Swig_var_AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC_get, Swig_var_AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC_set);
  SWIG_addvarlink(globals, "AllocRejCode_COMMISSION_DIFFERENCE", Swig_var_AllocRejCode_COMMISSION_DIFFERENCE_get, Swig_var_AllocRejCode_COMMISSION_DIFFERENCE_set);
  SWIG_addvarlink(globals, "AllocRejCode_UNKNOWN_ORDER_ID", Swig_var_AllocRejCode_UNKNOWN_ORDER_ID_get, Swig_var_AllocRejCode_UNKNOWN_ORDER_ID_set);
  SWIG_addvarlink(globals, "AllocRejCode_UNKNOWN_LIST_ID", Swig_var_AllocRejCode_UNKNOWN_LIST_ID_get, Swig_var_AllocRejCode_UNKNOWN_LIST_ID_set);
  SWIG_addvarlink(globals, "AllocRejCode_OTHER_SEE_TEXT", Swig_var_AllocRejCode_OTHER_SEE_TEXT_get, Swig_var_AllocRejCode_OTHER_SEE_TEXT_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_ALLOCATED_QUANTITY", Swig_var_AllocRejCode_INCORRECT_ALLOCATED_QUANTITY_get, Swig_var_AllocRejCode_INCORRECT_ALLOCATED_QUANTITY_set);
  SWIG_addvarlink(globals, "AllocRejCode_CALCULATION_DIFFERENCE", Swig_var_AllocRejCode_CALCULATION_DIFFERENCE_get, Swig_var_AllocRejCode_CALCULATION_DIFFERENCE_set);
  SWIG_addvarlink(globals, "AllocRejCode_UNKNOWN_OR_STALE_EXEC_ID", Swig_var_AllocRejCode_UNKNOWN_OR_STALE_EXEC_ID_get, Swig_var_AllocRejCode_UNKNOWN_OR_STALE_EXEC_ID_set);
  SWIG_addvarlink(globals, "AllocRejCode_MISMATCHED_DATA", Swig_var_AllocRejCode_MISMATCHED_DATA_get, Swig_var_AllocRejCode_MISMATCHED_DATA_set);
  SWIG_addvarlink(globals, "AllocRejCode_UNKNOWN_CL_ORD_ID", Swig_var_AllocRejCode_UNKNOWN_CL_ORD_ID_get, Swig_var_AllocRejCode_UNKNOWN_CL_ORD_ID_set);
  SWIG_addvarlink(globals, "AllocRejCode_WAREHOUSE_REQUEST_REJECTED", Swig_var_AllocRejCode_WAREHOUSE_REQUEST_REJECTED_get, Swig_var_AllocRejCode_WAREHOUSE_REQUEST_REJECTED_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_AVERAGE_PRICE", Swig_var_AllocRejCode_INCORRECT_AVERAGE_PRICE_get, Swig_var_AllocRejCode_INCORRECT_AVERAGE_PRICE_set);
  SWIG_addvarlink(globals, "AllocRejCode_DUPLICATE_OR_MISSING_INDIVIDUAL_ALLOC_ID", Swig_var_AllocRejCode_DUPLICATE_OR_MISSING_INDIVIDUAL_ALLOC_ID_get, Swig_var_AllocRejCode_DUPLICATE_OR_MISSING_INDIVIDUAL_ALLOC_ID_set);
  SWIG_addvarlink(globals, "AllocRejCode_TRADE_NOT_RECOGNIZED", Swig_var_AllocRejCode_TRADE_NOT_RECOGNIZED_get, Swig_var_AllocRejCode_TRADE_NOT_RECOGNIZED_set);
  SWIG_addvarlink(globals, "AllocRejCode_DUPLICATE_TRADE", Swig_var_AllocRejCode_DUPLICATE_TRADE_get, Swig_var_AllocRejCode_DUPLICATE_TRADE_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_OR_MISSING_INSTRUMENT", Swig_var_AllocRejCode_INCORRECT_OR_MISSING_INSTRUMENT_get, Swig_var_AllocRejCode_INCORRECT_OR_MISSING_INSTRUMENT_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_OR_MISSING_SETTL_DATE", Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SETTL_DATE_get, Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SETTL_DATE_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_OR_MISSING_FUND_ID_OR_FUND_NAME", Swig_var_AllocRejCode_INCORRECT_OR_MISSING_FUND_ID_OR_FUND_NAME_get, Swig_var_AllocRejCode_INCORRECT_OR_MISSING_FUND_ID_OR_FUND_NAME_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_OR_MISSING_SETTL_INSTRUCTIONS", Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SETTL_INSTRUCTIONS_get, Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SETTL_INSTRUCTIONS_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_OR_MISSING_FEES", Swig_var_AllocRejCode_INCORRECT_OR_MISSING_FEES_get, Swig_var_AllocRejCode_INCORRECT_OR_MISSING_FEES_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_OR_MISSING_TAX", Swig_var_AllocRejCode_INCORRECT_OR_MISSING_TAX_get, Swig_var_AllocRejCode_INCORRECT_OR_MISSING_TAX_set);
  SWIG_addvarlink(globals, "AllocRejCode_UNKNOWN_OR_MISSING_PARTY", Swig_var_AllocRejCode_UNKNOWN_OR_MISSING_PARTY_get, Swig_var_AllocRejCode_UNKNOWN_OR_MISSING_PARTY_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_OR_MISSING_SIDE", Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SIDE_get, Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SIDE_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_OR_MISSING_NET_MONEY", Swig_var_AllocRejCode_INCORRECT_OR_MISSING_NET_MONEY_get, Swig_var_AllocRejCode_INCORRECT_OR_MISSING_NET_MONEY_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_OR_MISSING_TRADE_DATE", Swig_var_AllocRejCode_INCORRECT_OR_MISSING_TRADE_DATE_get, Swig_var_AllocRejCode_INCORRECT_OR_MISSING_TRADE_DATE_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_OR_MISSING_SETTL_CCY_INSTRUCTIONS", Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SETTL_CCY_INSTRUCTIONS_get, Swig_var_AllocRejCode_INCORRECT_OR_MISSING_SETTL_CCY_INSTRUCTIONS_set);
  SWIG_addvarlink(globals, "AllocRejCode_INCORRECT_OR_MISSING_PROCESS_CODE", Swig_var_AllocRejCode_INCORRECT_OR_MISSING_PROCESS_CODE_get, Swig_var_AllocRejCode_INCORRECT_OR_MISSING_PROCESS_CODE_set);
  SWIG_addvarlink(globals, "AllocRejCode_OTHER", Swig_var_AllocRejCode_OTHER_get, Swig_var_AllocRejCode_OTHER_set);
  SWIG_addvarlink(globals, "EmailType_NEW", Swig_var_EmailType_NEW_get, Swig_var_EmailType_NEW_set);
  SWIG_addvarlink(globals, "EmailType_REPLY", Swig_var_EmailType_REPLY_get, Swig_var_EmailType_REPLY_set);
  SWIG_addvarlink(globals, "EmailType_ADMIN_REPLY", Swig_var_EmailType_ADMIN_REPLY_get, Swig_var_EmailType_ADMIN_REPLY_set);
  SWIG_addvarlink(globals, "ExDestination_NONE", Swig_var_ExDestination_NONE_get, Swig_var_ExDestination_NONE_set);
  SWIG_addvarlink(globals, "ExDestination_POSIT", Swig_var_ExDestination_POSIT_get, Swig_var_ExDestination_POSIT_set);
  SWIG_addvarlink(globals, "CxlRejReason_TOO_LATE_TO_CANCEL", Swig_var_CxlRejReason_TOO_LATE_TO_CANCEL_get, Swig_var_CxlRejReason_TOO_LATE_TO_CANCEL_set);
  SWIG_addvarlink(globals, "CxlRejReason_UNKNOWN_ORDER", Swig_var_CxlRejReason_UNKNOWN_ORDER_get, Swig_var_CxlRejReason_UNKNOWN_ORDER_set);
  SWIG_addvarlink(globals, "CxlRejReason_BROKER_CREDIT", Swig_var_CxlRejReason_BROKER_CREDIT_get, Swig_var_CxlRejReason_BROKER_CREDIT_set);
  SWIG_addvarlink(globals, "CxlRejReason_ORDER_ALREADY_IN_PENDING_STATUS", Swig_var_CxlRejReason_ORDER_ALREADY_IN_PENDING_STATUS_get, Swig_var_CxlRejReason_ORDER_ALREADY_IN_PENDING_STATUS_set);
  SWIG_addvarlink(globals, "CxlRejReason_DUPLICATE_CL_ORD_ID", Swig_var_CxlRejReason_DUPLICATE_CL_ORD_ID_get, Swig_var_CxlRejReason_DUPLICATE_CL_ORD_ID_set);
  SWIG_addvarlink(globals, "CxlRejReason_ORIG_ORD_MOD_TIME", Swig_var_CxlRejReason_ORIG_ORD_MOD_TIME_get, Swig_var_CxlRejReason_ORIG_ORD_MOD_TIME_set);
  SWIG_addvarlink(globals, "CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST", Swig_var_CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST_get, Swig_var_CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST_set);
  SWIG_addvarlink(globals, "CxlRejReason_OTHER", Swig_var_CxlRejReason_OTHER_get, Swig_var_CxlRejReason_OTHER_set);
  SWIG_addvarlink(globals, "CxlRejReason_INVALID_PRICE_INCREMENT", Swig_var_CxlRejReason_INVALID_PRICE_INCREMENT_get, Swig_var_CxlRejReason_INVALID_PRICE_INCREMENT_set);
  SWIG_addvarlink(globals, "CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE", Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_get, Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_set);
  SWIG_addvarlink(globals, "CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND", Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get, Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set);
  SWIG_addvarlink(globals, "OrdRejReason_BROKER_CREDIT", Swig_var_OrdRejReason_BROKER_CREDIT_get, Swig_var_OrdRejReason_BROKER_CREDIT_set);
  SWIG_addvarlink(globals, "OrdRejReason_UNKNOWN_SYMBOL", Swig_var_OrdRejReason_UNKNOWN_SYMBOL_get, Swig_var_OrdRejReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(globals, "OrdRejReason_EXCHANGE_CLOSED", Swig_var_OrdRejReason_EXCHANGE_CLOSED_get, Swig_var_OrdRejReason_EXCHANGE_CLOSED_set);
  SWIG_addvarlink(globals, "OrdRejReason_ORDER_EXCEEDS_LIMIT", Swig_var_OrdRejReason_ORDER_EXCEEDS_LIMIT_get, Swig_var_OrdRejReason_ORDER_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(globals, "OrdRejReason_TOO_LATE_TO_ENTER", Swig_var_OrdRejReason_TOO_LATE_TO_ENTER_get, Swig_var_OrdRejReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(globals, "OrdRejReason_UNKNOWN_ORDER", Swig_var_OrdRejReason_UNKNOWN_ORDER_get, Swig_var_OrdRejReason_UNKNOWN_ORDER_set);
  SWIG_addvarlink(globals, "OrdRejReason_DUPLICATE_ORDER", Swig_var_OrdRejReason_DUPLICATE_ORDER_get, Swig_var_OrdRejReason_DUPLICATE_ORDER_set);
  SWIG_addvarlink(globals, "OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER", Swig_var_OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER_get, Swig_var_OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER_set);
  SWIG_addvarlink(globals, "OrdRejReason_STALE_ORDER", Swig_var_OrdRejReason_STALE_ORDER_get, Swig_var_OrdRejReason_STALE_ORDER_set);
  SWIG_addvarlink(globals, "OrdRejReason_TRADE_ALONG_REQUIRED", Swig_var_OrdRejReason_TRADE_ALONG_REQUIRED_get, Swig_var_OrdRejReason_TRADE_ALONG_REQUIRED_set);
  SWIG_addvarlink(globals, "OrdRejReason_INVALID_INVESTOR_ID", Swig_var_OrdRejReason_INVALID_INVESTOR_ID_get, Swig_var_OrdRejReason_INVALID_INVESTOR_ID_set);
  SWIG_addvarlink(globals, "OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC", Swig_var_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get, Swig_var_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC_set);
  SWIG_addvarlink(globals, "OrdRejReason_SURVEILLENCE_OPTION", Swig_var_OrdRejReason_SURVEILLENCE_OPTION_get, Swig_var_OrdRejReason_SURVEILLENCE_OPTION_set);
  SWIG_addvarlink(globals, "OrdRejReason_INCORRECT_QUANTITY", Swig_var_OrdRejReason_INCORRECT_QUANTITY_get, Swig_var_OrdRejReason_INCORRECT_QUANTITY_set);
  SWIG_addvarlink(globals, "OrdRejReason_INCORRECT_ALLOCATED_QUANTITY", Swig_var_OrdRejReason_INCORRECT_ALLOCATED_QUANTITY_get, Swig_var_OrdRejReason_INCORRECT_ALLOCATED_QUANTITY_set);
  SWIG_addvarlink(globals, "OrdRejReason_UNKNOWN_ACCOUNT", Swig_var_OrdRejReason_UNKNOWN_ACCOUNT_get, Swig_var_OrdRejReason_UNKNOWN_ACCOUNT_set);
  SWIG_addvarlink(globals, "OrdRejReason_OTHER", Swig_var_OrdRejReason_OTHER_get, Swig_var_OrdRejReason_OTHER_set);
  SWIG_addvarlink(globals, "OrdRejReason_INVALID_PRICE_INCREMENT", Swig_var_OrdRejReason_INVALID_PRICE_INCREMENT_get, Swig_var_OrdRejReason_INVALID_PRICE_INCREMENT_set);
  SWIG_addvarlink(globals, "OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND", Swig_var_OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get, Swig_var_OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set);
  SWIG_addvarlink(globals, "OrdRejReason_SURVEILLANCE_OPTION", Swig_var_OrdRejReason_SURVEILLANCE_OPTION_get, Swig_var_OrdRejReason_SURVEILLANCE_OPTION_set);
  SWIG_addvarlink(globals, "OrdRejReason_REFERENCE_PRICE_NOT_AVAILABLE", Swig_var_OrdRejReason_REFERENCE_PRICE_NOT_AVAILABLE_get, Swig_var_OrdRejReason_REFERENCE_PRICE_NOT_AVAILABLE_set);
  SWIG_addvarlink(globals, "OrdRejReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD", Swig_var_OrdRejReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD_get, Swig_var_OrdRejReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD_set);
  SWIG_addvarlink(globals, "OrdRejReason_ALGORITHM_RISK_THRESHOLD_BREACHED", Swig_var_OrdRejReason_ALGORITHM_RISK_THRESHOLD_BREACHED_get, Swig_var_OrdRejReason_ALGORITHM_RISK_THRESHOLD_BREACHED_set);
  SWIG_addvarlink(globals, "OrdRejReason_SHORT_SELL_NOT_PERMITTED", Swig_var_OrdRejReason_SHORT_SELL_NOT_PERMITTED_get, Swig_var_OrdRejReason_SHORT_SELL_NOT_PERMITTED_set);
  SWIG_addvarlink(globals, "OrdRejReason_SHORT_SELL_SECURITY_PRE_BORROW_RESTRICTION", Swig_var_OrdRejReason_SHORT_SELL_SECURITY_PRE_BORROW_RESTRICTION_get, Swig_var_OrdRejReason_SHORT_SELL_SECURITY_PRE_BORROW_RESTRICTION_set);
  SWIG_addvarlink(globals, "OrdRejReason_SHORT_SELL_ACCOUNT_PRE_BORROW_RESTRICTION", Swig_var_OrdRejReason_SHORT_SELL_ACCOUNT_PRE_BORROW_RESTRICTION_get, Swig_var_OrdRejReason_SHORT_SELL_ACCOUNT_PRE_BORROW_RESTRICTION_set);
  SWIG_addvarlink(globals, "OrdRejReason_INSUFFICIENT_CREDIT_LIMIT", Swig_var_OrdRejReason_INSUFFICIENT_CREDIT_LIMIT_get, Swig_var_OrdRejReason_INSUFFICIENT_CREDIT_LIMIT_set);
  SWIG_addvarlink(globals, "OrdRejReason_EXCEEDED_CLIP_SIZE_LIMIT", Swig_var_OrdRejReason_EXCEEDED_CLIP_SIZE_LIMIT_get, Swig_var_OrdRejReason_EXCEEDED_CLIP_SIZE_LIMIT_set);
  SWIG_addvarlink(globals, "OrdRejReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT", Swig_var_OrdRejReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT_get, Swig_var_OrdRejReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT_set);
  SWIG_addvarlink(globals, "OrdRejReason_EXCEEDED_DV01_PV01_LIMIT", Swig_var_OrdRejReason_EXCEEDED_DV01_PV01_LIMIT_get, Swig_var_OrdRejReason_EXCEEDED_DV01_PV01_LIMIT_set);
  SWIG_addvarlink(globals, "OrdRejReason_EXCEEDED_CS01_LIMIT", Swig_var_OrdRejReason_EXCEEDED_CS01_LIMIT_get, Swig_var_OrdRejReason_EXCEEDED_CS01_LIMIT_set);
  SWIG_addvarlink(globals, "IOIQualifier_ALL_OR_NONE", Swig_var_IOIQualifier_ALL_OR_NONE_get, Swig_var_IOIQualifier_ALL_OR_NONE_set);
  SWIG_addvarlink(globals, "IOIQualifier_AT_THE_CLOSE", Swig_var_IOIQualifier_AT_THE_CLOSE_get, Swig_var_IOIQualifier_AT_THE_CLOSE_set);
  SWIG_addvarlink(globals, "IOIQualifier_IN_TOUCH_WITH", Swig_var_IOIQualifier_IN_TOUCH_WITH_get, Swig_var_IOIQualifier_IN_TOUCH_WITH_set);
  SWIG_addvarlink(globals, "IOIQualifier_LIMIT", Swig_var_IOIQualifier_LIMIT_get, Swig_var_IOIQualifier_LIMIT_set);
  SWIG_addvarlink(globals, "IOIQualifier_MORE_BEHIND", Swig_var_IOIQualifier_MORE_BEHIND_get, Swig_var_IOIQualifier_MORE_BEHIND_set);
  SWIG_addvarlink(globals, "IOIQualifier_AT_THE_OPEN", Swig_var_IOIQualifier_AT_THE_OPEN_get, Swig_var_IOIQualifier_AT_THE_OPEN_set);
  SWIG_addvarlink(globals, "IOIQualifier_TAKING_A_POSITION", Swig_var_IOIQualifier_TAKING_A_POSITION_get, Swig_var_IOIQualifier_TAKING_A_POSITION_set);
  SWIG_addvarlink(globals, "IOIQualifier_AT_THE_MARKET", Swig_var_IOIQualifier_AT_THE_MARKET_get, Swig_var_IOIQualifier_AT_THE_MARKET_set);
  SWIG_addvarlink(globals, "IOIQualifier_PORTFOLIO_SHOWN", Swig_var_IOIQualifier_PORTFOLIO_SHOWN_get, Swig_var_IOIQualifier_PORTFOLIO_SHOWN_set);
  SWIG_addvarlink(globals, "IOIQualifier_THROUGH_THE_DAY", Swig_var_IOIQualifier_THROUGH_THE_DAY_get, Swig_var_IOIQualifier_THROUGH_THE_DAY_set);
  SWIG_addvarlink(globals, "IOIQualifier_VERSUS", Swig_var_IOIQualifier_VERSUS_get, Swig_var_IOIQualifier_VERSUS_set);
  SWIG_addvarlink(globals, "IOIQualifier_INDICATION", Swig_var_IOIQualifier_INDICATION_get, Swig_var_IOIQualifier_INDICATION_set);
  SWIG_addvarlink(globals, "IOIQualifier_CROSSING_OPPORTUNITY", Swig_var_IOIQualifier_CROSSING_OPPORTUNITY_get, Swig_var_IOIQualifier_CROSSING_OPPORTUNITY_set);
  SWIG_addvarlink(globals, "IOIQualifier_AT_THE_MIDPOINT", Swig_var_IOIQualifier_AT_THE_MIDPOINT_get, Swig_var_IOIQualifier_AT_THE_MIDPOINT_set);
  SWIG_addvarlink(globals, "IOIQualifier_PRE_OPEN", Swig_var_IOIQualifier_PRE_OPEN_get, Swig_var_IOIQualifier_PRE_OPEN_set);
  SWIG_addvarlink(globals, "IOIQualifier_READY_TO_TRADE", Swig_var_IOIQualifier_READY_TO_TRADE_get, Swig_var_IOIQualifier_READY_TO_TRADE_set);
  SWIG_addvarlink(globals, "IOIQualifier_VWAP", Swig_var_IOIQualifier_VWAP_get, Swig_var_IOIQualifier_VWAP_set);
  SWIG_addvarlink(globals, "IOIQualifier_MARKET_ON_CLOSE", Swig_var_IOIQualifier_MARKET_ON_CLOSE_get, Swig_var_IOIQualifier_MARKET_ON_CLOSE_set);
  SWIG_addvarlink(globals, "IOIQualifier_AXE", Swig_var_IOIQualifier_AXE_get, Swig_var_IOIQualifier_AXE_set);
  SWIG_addvarlink(globals, "IOIQualifier_AXE_ON_BID", Swig_var_IOIQualifier_AXE_ON_BID_get, Swig_var_IOIQualifier_AXE_ON_BID_set);
  SWIG_addvarlink(globals, "IOIQualifier_AXE_ON_OFFER", Swig_var_IOIQualifier_AXE_ON_OFFER_get, Swig_var_IOIQualifier_AXE_ON_OFFER_set);
  SWIG_addvarlink(globals, "IOIQualifier_CLIENT_NATURAL_WORKING", Swig_var_IOIQualifier_CLIENT_NATURAL_WORKING_get, Swig_var_IOIQualifier_CLIENT_NATURAL_WORKING_set);
  SWIG_addvarlink(globals, "IOIQualifier_POSITION_WANTED", Swig_var_IOIQualifier_POSITION_WANTED_get, Swig_var_IOIQualifier_POSITION_WANTED_set);
  SWIG_addvarlink(globals, "IOIQualifier_MARKET_MAKING", Swig_var_IOIQualifier_MARKET_MAKING_get, Swig_var_IOIQualifier_MARKET_MAKING_set);
  SWIG_addvarlink(globals, "IOIQualifier_CLIENT_NATURAL_BLOCK", Swig_var_IOIQualifier_CLIENT_NATURAL_BLOCK_get, Swig_var_IOIQualifier_CLIENT_NATURAL_BLOCK_set);
  SWIG_addvarlink(globals, "IOIQualifier_UNWIND", Swig_var_IOIQualifier_UNWIND_get, Swig_var_IOIQualifier_UNWIND_set);
  SWIG_addvarlink(globals, "IOIQualifier_QUANTITY_NEGOTIABLE", Swig_var_IOIQualifier_QUANTITY_NEGOTIABLE_get, Swig_var_IOIQualifier_QUANTITY_NEGOTIABLE_set);
  SWIG_addvarlink(globals, "IOIQualifier_ALLOW_LATE_BIDS", Swig_var_IOIQualifier_ALLOW_LATE_BIDS_get, Swig_var_IOIQualifier_ALLOW_LATE_BIDS_set);
  SWIG_addvarlink(globals, "IOIQualifier_IMMEDIATE_OR_COUNTER", Swig_var_IOIQualifier_IMMEDIATE_OR_COUNTER_get, Swig_var_IOIQualifier_IMMEDIATE_OR_COUNTER_set);
  SWIG_addvarlink(globals, "IOIQualifier_AUTO_TRADE", Swig_var_IOIQualifier_AUTO_TRADE_get, Swig_var_IOIQualifier_AUTO_TRADE_set);
  SWIG_addvarlink(globals, "IOIQualifier_AUTOMATIC_SPOT", Swig_var_IOIQualifier_AUTOMATIC_SPOT_get, Swig_var_IOIQualifier_AUTOMATIC_SPOT_set);
  SWIG_addvarlink(globals, "IOIQualifier_PLATFORM_CALCULATED_SPOT", Swig_var_IOIQualifier_PLATFORM_CALCULATED_SPOT_get, Swig_var_IOIQualifier_PLATFORM_CALCULATED_SPOT_set);
  SWIG_addvarlink(globals, "IOIQualifier_OUTSIDE_SPREAD", Swig_var_IOIQualifier_OUTSIDE_SPREAD_get, Swig_var_IOIQualifier_OUTSIDE_SPREAD_set);
  SWIG_addvarlink(globals, "IOIQualifier_DEFERRED_SPOT", Swig_var_IOIQualifier_DEFERRED_SPOT_get, Swig_var_IOIQualifier_DEFERRED_SPOT_set);
  SWIG_addvarlink(globals, "IOIQualifier_NEGOTIATED_SPOT", Swig_var_IOIQualifier_NEGOTIATED_SPOT_get, Swig_var_IOIQualifier_NEGOTIATED_SPOT_set);
  SWIG_addvarlink(globals, "ReportToExch_NO", Swig_var_ReportToExch_NO_get, Swig_var_ReportToExch_NO_set);
  SWIG_addvarlink(globals, "ReportToExch_YES", Swig_var_ReportToExch_YES_get, Swig_var_ReportToExch_YES_set);
  SWIG_addvarlink(globals, "LocateReqd_NO", Swig_var_LocateReqd_NO_get, Swig_var_LocateReqd_NO_set);
  SWIG_addvarlink(globals, "LocateReqd_YES", Swig_var_LocateReqd_YES_get, Swig_var_LocateReqd_YES_set);
  SWIG_addvarlink(globals, "ForexReq_NO", Swig_var_ForexReq_NO_get, Swig_var_ForexReq_NO_set);
  SWIG_addvarlink(globals, "ForexReq_YES", Swig_var_ForexReq_YES_get, Swig_var_ForexReq_YES_set);
  SWIG_addvarlink(globals, "CxlType_FULL_REMAINING_QUANTITY", Swig_var_CxlType_FULL_REMAINING_QUANTITY_get, Swig_var_CxlType_FULL_REMAINING_QUANTITY_set);
  SWIG_addvarlink(globals, "CxlType_PARTIAL_CANCEL", Swig_var_CxlType_PARTIAL_CANCEL_get, Swig_var_CxlType_PARTIAL_CANCEL_set);
  SWIG_addvarlink(globals, "DKReason_UNKNOWN_SYMBOL", Swig_var_DKReason_UNKNOWN_SYMBOL_get, Swig_var_DKReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(globals, "DKReason_WRONG_SIDE", Swig_var_DKReason_WRONG_SIDE_get, Swig_var_DKReason_WRONG_SIDE_set);
  SWIG_addvarlink(globals, "DKReason_QUANTITY_EXCEEDS_ORDER", Swig_var_DKReason_QUANTITY_EXCEEDS_ORDER_get, Swig_var_DKReason_QUANTITY_EXCEEDS_ORDER_set);
  SWIG_addvarlink(globals, "DKReason_NO_MATCHING_ORDER", Swig_var_DKReason_NO_MATCHING_ORDER_get, Swig_var_DKReason_NO_MATCHING_ORDER_set);
  SWIG_addvarlink(globals, "DKReason_PRICE_EXCEEDS_LIMIT", Swig_var_DKReason_PRICE_EXCEEDS_LIMIT_get, Swig_var_DKReason_PRICE_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(globals, "DKReason_OTHER", Swig_var_DKReason_OTHER_get, Swig_var_DKReason_OTHER_set);
  SWIG_addvarlink(globals, "DKReason_CALCULATION_DIFFERENCE", Swig_var_DKReason_CALCULATION_DIFFERENCE_get, Swig_var_DKReason_CALCULATION_DIFFERENCE_set);
  SWIG_addvarlink(globals, "DKReason_NO_MATCHING_EXECUTION_REPORT", Swig_var_DKReason_NO_MATCHING_EXECUTION_REPORT_get, Swig_var_DKReason_NO_MATCHING_EXECUTION_REPORT_set);
  SWIG_addvarlink(globals, "IOINaturalFlag_NO", Swig_var_IOINaturalFlag_NO_get, Swig_var_IOINaturalFlag_NO_set);
  SWIG_addvarlink(globals, "IOINaturalFlag_YES", Swig_var_IOINaturalFlag_YES_get, Swig_var_IOINaturalFlag_YES_set);
  SWIG_addvarlink(globals, "MiscFeeType_REGULATORY", Swig_var_MiscFeeType_REGULATORY_get, Swig_var_MiscFeeType_REGULATORY_set);
  SWIG_addvarlink(globals, "MiscFeeType_TAX", Swig_var_MiscFeeType_TAX_get, Swig_var_MiscFeeType_TAX_set);
  SWIG_addvarlink(globals, "MiscFeeType_LOCAL_COMMISSION", Swig_var_MiscFeeType_LOCAL_COMMISSION_get, Swig_var_MiscFeeType_LOCAL_COMMISSION_set);
  SWIG_addvarlink(globals, "MiscFeeType_EXCHANGE_FEES", Swig_var_MiscFeeType_EXCHANGE_FEES_get, Swig_var_MiscFeeType_EXCHANGE_FEES_set);
  SWIG_addvarlink(globals, "MiscFeeType_STAMP", Swig_var_MiscFeeType_STAMP_get, Swig_var_MiscFeeType_STAMP_set);
  SWIG_addvarlink(globals, "MiscFeeType_LEVY", Swig_var_MiscFeeType_LEVY_get, Swig_var_MiscFeeType_LEVY_set);
  SWIG_addvarlink(globals, "MiscFeeType_OTHER", Swig_var_MiscFeeType_OTHER_get, Swig_var_MiscFeeType_OTHER_set);
  SWIG_addvarlink(globals, "MiscFeeType_MARKUP", Swig_var_MiscFeeType_MARKUP_get, Swig_var_MiscFeeType_MARKUP_set);
  SWIG_addvarlink(globals, "MiscFeeType_CONSUMPTION_TAX", Swig_var_MiscFeeType_CONSUMPTION_TAX_get, Swig_var_MiscFeeType_CONSUMPTION_TAX_set);
  SWIG_addvarlink(globals, "MiscFeeType_PER_TRANSACTION", Swig_var_MiscFeeType_PER_TRANSACTION_get, Swig_var_MiscFeeType_PER_TRANSACTION_set);
  SWIG_addvarlink(globals, "MiscFeeType_CONVERSION", Swig_var_MiscFeeType_CONVERSION_get, Swig_var_MiscFeeType_CONVERSION_set);
  SWIG_addvarlink(globals, "MiscFeeType_AGENT", Swig_var_MiscFeeType_AGENT_get, Swig_var_MiscFeeType_AGENT_set);
  SWIG_addvarlink(globals, "MiscFeeType_TRANSFER_FEE", Swig_var_MiscFeeType_TRANSFER_FEE_get, Swig_var_MiscFeeType_TRANSFER_FEE_set);
  SWIG_addvarlink(globals, "MiscFeeType_SECURITY_LENDING", Swig_var_MiscFeeType_SECURITY_LENDING_get, Swig_var_MiscFeeType_SECURITY_LENDING_set);
  SWIG_addvarlink(globals, "MiscFeeType_TRADE_REPORTING", Swig_var_MiscFeeType_TRADE_REPORTING_get, Swig_var_MiscFeeType_TRADE_REPORTING_set);
  SWIG_addvarlink(globals, "MiscFeeType_TAX_ON_PRINCIPAL_AMOUNT", Swig_var_MiscFeeType_TAX_ON_PRINCIPAL_AMOUNT_get, Swig_var_MiscFeeType_TAX_ON_PRINCIPAL_AMOUNT_set);
  SWIG_addvarlink(globals, "MiscFeeType_TAX_ON_ACCRUED_INTEREST_AMOUNT", Swig_var_MiscFeeType_TAX_ON_ACCRUED_INTEREST_AMOUNT_get, Swig_var_MiscFeeType_TAX_ON_ACCRUED_INTEREST_AMOUNT_set);
  SWIG_addvarlink(globals, "MiscFeeType_NEW_ISSUANCE_FEE", Swig_var_MiscFeeType_NEW_ISSUANCE_FEE_get, Swig_var_MiscFeeType_NEW_ISSUANCE_FEE_set);
  SWIG_addvarlink(globals, "MiscFeeType_SERVICE_FEE", Swig_var_MiscFeeType_SERVICE_FEE_get, Swig_var_MiscFeeType_SERVICE_FEE_set);
  SWIG_addvarlink(globals, "MiscFeeType_ODD_LOT_FEE", Swig_var_MiscFeeType_ODD_LOT_FEE_get, Swig_var_MiscFeeType_ODD_LOT_FEE_set);
  SWIG_addvarlink(globals, "MiscFeeType_AUCTION_FEE", Swig_var_MiscFeeType_AUCTION_FEE_get, Swig_var_MiscFeeType_AUCTION_FEE_set);
  SWIG_addvarlink(globals, "MiscFeeType_VALUE_ADDED_TAX", Swig_var_MiscFeeType_VALUE_ADDED_TAX_get, Swig_var_MiscFeeType_VALUE_ADDED_TAX_set);
  SWIG_addvarlink(globals, "MiscFeeType_SALES_TAX", Swig_var_MiscFeeType_SALES_TAX_get, Swig_var_MiscFeeType_SALES_TAX_set);
  SWIG_addvarlink(globals, "MiscFeeType_EXECUTION_FEE", Swig_var_MiscFeeType_EXECUTION_FEE_get, Swig_var_MiscFeeType_EXECUTION_FEE_set);
  SWIG_addvarlink(globals, "MiscFeeType_ORDER_ENTRY_FEE", Swig_var_MiscFeeType_ORDER_ENTRY_FEE_get, Swig_var_MiscFeeType_ORDER_ENTRY_FEE_set);
  SWIG_addvarlink(globals, "MiscFeeType_ORDER_MODIFICATION_FEE", Swig_var_MiscFeeType_ORDER_MODIFICATION_FEE_get, Swig_var_MiscFeeType_ORDER_MODIFICATION_FEE_set);
  SWIG_addvarlink(globals, "MiscFeeType_ORDERS_CANCELLATION_FEE", Swig_var_MiscFeeType_ORDERS_CANCELLATION_FEE_get, Swig_var_MiscFeeType_ORDERS_CANCELLATION_FEE_set);
  SWIG_addvarlink(globals, "MiscFeeType_MARKET_DATA_ACCESS_FEE", Swig_var_MiscFeeType_MARKET_DATA_ACCESS_FEE_get, Swig_var_MiscFeeType_MARKET_DATA_ACCESS_FEE_set);
  SWIG_addvarlink(globals, "MiscFeeType_MARKET_DATA_TERMINAL_FEE", Swig_var_MiscFeeType_MARKET_DATA_TERMINAL_FEE_get, Swig_var_MiscFeeType_MARKET_DATA_TERMINAL_FEE_set);
  SWIG_addvarlink(globals, "MiscFeeType_MARKET_DATA_VOLUME_FEE", Swig_var_MiscFeeType_MARKET_DATA_VOLUME_FEE_get, Swig_var_MiscFeeType_MARKET_DATA_VOLUME_FEE_set);
  SWIG_addvarlink(globals, "MiscFeeType_CLEARING_FEE", Swig_var_MiscFeeType_CLEARING_FEE_get, Swig_var_MiscFeeType_CLEARING_FEE_set);
  SWIG_addvarlink(globals, "MiscFeeType_SETTLEMENT_FEE", Swig_var_MiscFeeType_SETTLEMENT_FEE_get, Swig_var_MiscFeeType_SETTLEMENT_FEE_set);
  SWIG_addvarlink(globals, "MiscFeeType_REBATES", Swig_var_MiscFeeType_REBATES_get, Swig_var_MiscFeeType_REBATES_set);
  SWIG_addvarlink(globals, "MiscFeeType_DISCOUNTS", Swig_var_MiscFeeType_DISCOUNTS_get, Swig_var_MiscFeeType_DISCOUNTS_set);
  SWIG_addvarlink(globals, "MiscFeeType_PAYMENTS", Swig_var_MiscFeeType_PAYMENTS_get, Swig_var_MiscFeeType_PAYMENTS_set);
  SWIG_addvarlink(globals, "MiscFeeType_NON_MONETARY_PAYMENTS", Swig_var_MiscFeeType_NON_MONETARY_PAYMENTS_get, Swig_var_MiscFeeType_NON_MONETARY_PAYMENTS_set);
  SWIG_addvarlink(globals, "ExecType_NEW", Swig_var_ExecType_NEW_get, Swig_var_ExecType_NEW_set);
  SWIG_addvarlink(globals, "ExecType_PARTIAL_FILL", Swig_var_ExecType_PARTIAL_FILL_get, Swig_var_ExecType_PARTIAL_FILL_set);
  SWIG_addvarlink(globals, "ExecType_FILL", Swig_var_ExecType_FILL_get, Swig_var_ExecType_FILL_set);
  SWIG_addvarlink(globals, "ExecType_DONE_FOR_DAY", Swig_var_ExecType_DONE_FOR_DAY_get, Swig_var_ExecType_DONE_FOR_DAY_set);
  SWIG_addvarlink(globals, "ExecType_CANCELED", Swig_var_ExecType_CANCELED_get, Swig_var_ExecType_CANCELED_set);
  SWIG_addvarlink(globals, "ExecType_REPLACED", Swig_var_ExecType_REPLACED_get, Swig_var_ExecType_REPLACED_set);
  SWIG_addvarlink(globals, "ExecType_PENDING_CANCEL", Swig_var_ExecType_PENDING_CANCEL_get, Swig_var_ExecType_PENDING_CANCEL_set);
  SWIG_addvarlink(globals, "ExecType_STOPPED", Swig_var_ExecType_STOPPED_get, Swig_var_ExecType_STOPPED_set);
  SWIG_addvarlink(globals, "ExecType_REJECTED", Swig_var_ExecType_REJECTED_get, Swig_var_ExecType_REJECTED_set);
  SWIG_addvarlink(globals, "ExecType_SUSPENDED", Swig_var_ExecType_SUSPENDED_get, Swig_var_ExecType_SUSPENDED_set);
  SWIG_addvarlink(globals, "ExecType_PENDING_NEW", Swig_var_ExecType_PENDING_NEW_get, Swig_var_ExecType_PENDING_NEW_set);
  SWIG_addvarlink(globals, "ExecType_CALCULATED", Swig_var_ExecType_CALCULATED_get, Swig_var_ExecType_CALCULATED_set);
  SWIG_addvarlink(globals, "ExecType_EXPIRED", Swig_var_ExecType_EXPIRED_get, Swig_var_ExecType_EXPIRED_set);
  SWIG_addvarlink(globals, "ExecType_RESTATED", Swig_var_ExecType_RESTATED_get, Swig_var_ExecType_RESTATED_set);
  SWIG_addvarlink(globals, "ExecType_PENDING_REPLACE", Swig_var_ExecType_PENDING_REPLACE_get, Swig_var_ExecType_PENDING_REPLACE_set);
  SWIG_addvarlink(globals, "ExecType_TRADE", Swig_var_ExecType_TRADE_get, Swig_var_ExecType_TRADE_set);
  SWIG_addvarlink(globals, "ExecType_TRADE_CORRECT", Swig_var_ExecType_TRADE_CORRECT_get, Swig_var_ExecType_TRADE_CORRECT_set);
  SWIG_addvarlink(globals, "ExecType_TRADE_CANCEL", Swig_var_ExecType_TRADE_CANCEL_get, Swig_var_ExecType_TRADE_CANCEL_set);
  SWIG_addvarlink(globals, "ExecType_ORDER_STATUS", Swig_var_ExecType_ORDER_STATUS_get, Swig_var_ExecType_ORDER_STATUS_set);
  SWIG_addvarlink(globals, "ExecType_TRADE_IN_A_CLEARING_HOLD", Swig_var_ExecType_TRADE_IN_A_CLEARING_HOLD_get, Swig_var_ExecType_TRADE_IN_A_CLEARING_HOLD_set);
  SWIG_addvarlink(globals, "ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING", Swig_var_ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING_get, Swig_var_ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING_set);
  SWIG_addvarlink(globals, "ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM", Swig_var_ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM_get, Swig_var_ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM_set);
  SWIG_addvarlink(globals, "ExecType_LOCKED", Swig_var_ExecType_LOCKED_get, Swig_var_ExecType_LOCKED_set);
  SWIG_addvarlink(globals, "ExecType_RELEASED", Swig_var_ExecType_RELEASED_get, Swig_var_ExecType_RELEASED_set);
  SWIG_addvarlink(globals, "SettlCurrFxRateCalc_DIVIDE", Swig_var_SettlCurrFxRateCalc_DIVIDE_get, Swig_var_SettlCurrFxRateCalc_DIVIDE_set);
  SWIG_addvarlink(globals, "SettlCurrFxRateCalc_MULTIPLY", Swig_var_SettlCurrFxRateCalc_MULTIPLY_get, Swig_var_SettlCurrFxRateCalc_MULTIPLY_set);
  SWIG_addvarlink(globals, "SettlInstMode_DEFAULT", Swig_var_SettlInstMode_DEFAULT_get, Swig_var_SettlInstMode_DEFAULT_set);
  SWIG_addvarlink(globals, "SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED", Swig_var_SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED_get, Swig_var_SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED_set);
  SWIG_addvarlink(globals, "SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING", Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING_get, Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING_set);
  SWIG_addvarlink(globals, "SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING", Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING_get, Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING_set);
  SWIG_addvarlink(globals, "SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT", Swig_var_SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT_get, Swig_var_SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT_set);
  SWIG_addvarlink(globals, "SettlInstMode_REQUEST_REJECT", Swig_var_SettlInstMode_REQUEST_REJECT_get, Swig_var_SettlInstMode_REQUEST_REJECT_set);
  SWIG_addvarlink(globals, "SettlInstTransType_CANCEL", Swig_var_SettlInstTransType_CANCEL_get, Swig_var_SettlInstTransType_CANCEL_set);
  SWIG_addvarlink(globals, "SettlInstTransType_NEW", Swig_var_SettlInstTransType_NEW_get, Swig_var_SettlInstTransType_NEW_set);
  SWIG_addvarlink(globals, "SettlInstTransType_REPLACE", Swig_var_SettlInstTransType_REPLACE_get, Swig_var_SettlInstTransType_REPLACE_set);
  SWIG_addvarlink(globals, "SettlInstTransType_RESTATE", Swig_var_SettlInstTransType_RESTATE_get, Swig_var_SettlInstTransType_RESTATE_set);
  SWIG_addvarlink(globals, "SettlInstSource_BROKER_CREDIT", Swig_var_SettlInstSource_BROKER_CREDIT_get, Swig_var_SettlInstSource_BROKER_CREDIT_set);
  SWIG_addvarlink(globals, "SettlInstSource_INSTITUTION", Swig_var_SettlInstSource_INSTITUTION_get, Swig_var_SettlInstSource_INSTITUTION_set);
  SWIG_addvarlink(globals, "SettlInstSource_INVESTOR", Swig_var_SettlInstSource_INVESTOR_get, Swig_var_SettlInstSource_INVESTOR_set);
  SWIG_addvarlink(globals, "SettlLocation_CEDEL", Swig_var_SettlLocation_CEDEL_get, Swig_var_SettlLocation_CEDEL_set);
  SWIG_addvarlink(globals, "SettlLocation_DEPOSITORY_TRUST_COMPANY", Swig_var_SettlLocation_DEPOSITORY_TRUST_COMPANY_get, Swig_var_SettlLocation_DEPOSITORY_TRUST_COMPANY_set);
  SWIG_addvarlink(globals, "SettlLocation_EURO_CLEAR", Swig_var_SettlLocation_EURO_CLEAR_get, Swig_var_SettlLocation_EURO_CLEAR_set);
  SWIG_addvarlink(globals, "SettlLocation_FEDERAL_BOOK_ENTRY", Swig_var_SettlLocation_FEDERAL_BOOK_ENTRY_get, Swig_var_SettlLocation_FEDERAL_BOOK_ENTRY_set);
  SWIG_addvarlink(globals, "SettlLocation_LOCAL_MARKET_SETTLE_LOCATION", Swig_var_SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_get, Swig_var_SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_set);
  SWIG_addvarlink(globals, "SettlLocation_PHYSICAL", Swig_var_SettlLocation_PHYSICAL_get, Swig_var_SettlLocation_PHYSICAL_set);
  SWIG_addvarlink(globals, "SettlLocation_PARTICIPANT_TRUST_COMPANY", Swig_var_SettlLocation_PARTICIPANT_TRUST_COMPANY_get, Swig_var_SettlLocation_PARTICIPANT_TRUST_COMPANY_set);
  SWIG_addvarlink(globals, "SecurityType_BANKERS_ACCEPTANCE", Swig_var_SecurityType_BANKERS_ACCEPTANCE_get, Swig_var_SecurityType_BANKERS_ACCEPTANCE_set);
  SWIG_addvarlink(globals, "SecurityType_CERTIFICATE_OF_DEPOSIT", Swig_var_SecurityType_CERTIFICATE_OF_DEPOSIT_get, Swig_var_SecurityType_CERTIFICATE_OF_DEPOSIT_set);
  SWIG_addvarlink(globals, "SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION", Swig_var_SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_get, Swig_var_SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_set);
  SWIG_addvarlink(globals, "SecurityType_CORPORATE_BOND", Swig_var_SecurityType_CORPORATE_BOND_get, Swig_var_SecurityType_CORPORATE_BOND_set);
  SWIG_addvarlink(globals, "SecurityType_COMMERCIAL_PAPER", Swig_var_SecurityType_COMMERCIAL_PAPER_get, Swig_var_SecurityType_COMMERCIAL_PAPER_set);
  SWIG_addvarlink(globals, "SecurityType_CORPORATE_PRIVATE_PLACEMENT", Swig_var_SecurityType_CORPORATE_PRIVATE_PLACEMENT_get, Swig_var_SecurityType_CORPORATE_PRIVATE_PLACEMENT_set);
  SWIG_addvarlink(globals, "SecurityType_COMMON_STOCK", Swig_var_SecurityType_COMMON_STOCK_get, Swig_var_SecurityType_COMMON_STOCK_set);
  SWIG_addvarlink(globals, "SecurityType_FEDERAL_HOUSING_AUTHORITY", Swig_var_SecurityType_FEDERAL_HOUSING_AUTHORITY_get, Swig_var_SecurityType_FEDERAL_HOUSING_AUTHORITY_set);
  SWIG_addvarlink(globals, "SecurityType_FEDERAL_HOME_LOAN", Swig_var_SecurityType_FEDERAL_HOME_LOAN_get, Swig_var_SecurityType_FEDERAL_HOME_LOAN_set);
  SWIG_addvarlink(globals, "SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION", Swig_var_SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_get, Swig_var_SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_set);
  SWIG_addvarlink(globals, "SecurityType_FOREIGN_EXCHANGE_CONTRACT", Swig_var_SecurityType_FOREIGN_EXCHANGE_CONTRACT_get, Swig_var_SecurityType_FOREIGN_EXCHANGE_CONTRACT_set);
  SWIG_addvarlink(globals, "SecurityType_FUTURE", Swig_var_SecurityType_FUTURE_get, Swig_var_SecurityType_FUTURE_set);
  SWIG_addvarlink(globals, "SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION", Swig_var_SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_get, Swig_var_SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_set);
  SWIG_addvarlink(globals, "SecurityType_TREASURIES_AGENCY_DEBENTURE", Swig_var_SecurityType_TREASURIES_AGENCY_DEBENTURE_get, Swig_var_SecurityType_TREASURIES_AGENCY_DEBENTURE_set);
  SWIG_addvarlink(globals, "SecurityType_MUTUAL_FUND", Swig_var_SecurityType_MUTUAL_FUND_get, Swig_var_SecurityType_MUTUAL_FUND_set);
  SWIG_addvarlink(globals, "SecurityType_MORTGAGE_INTEREST_ONLY", Swig_var_SecurityType_MORTGAGE_INTEREST_ONLY_get, Swig_var_SecurityType_MORTGAGE_INTEREST_ONLY_set);
  SWIG_addvarlink(globals, "SecurityType_MORTGAGE_PRINCIPAL_ONLY", Swig_var_SecurityType_MORTGAGE_PRINCIPAL_ONLY_get, Swig_var_SecurityType_MORTGAGE_PRINCIPAL_ONLY_set);
  SWIG_addvarlink(globals, "SecurityType_MORTGAGE_PRIVATE_PLACEMENT", Swig_var_SecurityType_MORTGAGE_PRIVATE_PLACEMENT_get, Swig_var_SecurityType_MORTGAGE_PRIVATE_PLACEMENT_set);
  SWIG_addvarlink(globals, "SecurityType_MISCELLANEOUS_PASS_THROUGH", Swig_var_SecurityType_MISCELLANEOUS_PASS_THROUGH_get, Swig_var_SecurityType_MISCELLANEOUS_PASS_THROUGH_set);
  SWIG_addvarlink(globals, "SecurityType_MUNICIPAL_BOND", Swig_var_SecurityType_MUNICIPAL_BOND_get, Swig_var_SecurityType_MUNICIPAL_BOND_set);
  SWIG_addvarlink(globals, "SecurityType_NO_SECURITY_TYPE", Swig_var_SecurityType_NO_SECURITY_TYPE_get, Swig_var_SecurityType_NO_SECURITY_TYPE_set);
  SWIG_addvarlink(globals, "SecurityType_OPTION", Swig_var_SecurityType_OPTION_get, Swig_var_SecurityType_OPTION_set);
  SWIG_addvarlink(globals, "SecurityType_PREFERRED_STOCK", Swig_var_SecurityType_PREFERRED_STOCK_get, Swig_var_SecurityType_PREFERRED_STOCK_set);
  SWIG_addvarlink(globals, "SecurityType_REPURCHASE_AGREEMENT", Swig_var_SecurityType_REPURCHASE_AGREEMENT_get, Swig_var_SecurityType_REPURCHASE_AGREEMENT_set);
  SWIG_addvarlink(globals, "SecurityType_REVERSE_REPURCHASE_AGREEMENT", Swig_var_SecurityType_REVERSE_REPURCHASE_AGREEMENT_get, Swig_var_SecurityType_REVERSE_REPURCHASE_AGREEMENT_set);
  SWIG_addvarlink(globals, "SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION", Swig_var_SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_get, Swig_var_SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_set);
  SWIG_addvarlink(globals, "SecurityType_TIME_DEPOSIT", Swig_var_SecurityType_TIME_DEPOSIT_get, Swig_var_SecurityType_TIME_DEPOSIT_set);
  SWIG_addvarlink(globals, "SecurityType_US_TREASURY_BILL_OLD", Swig_var_SecurityType_US_TREASURY_BILL_OLD_get, Swig_var_SecurityType_US_TREASURY_BILL_OLD_set);
  SWIG_addvarlink(globals, "SecurityType_WARRANT", Swig_var_SecurityType_WARRANT_get, Swig_var_SecurityType_WARRANT_set);
  SWIG_addvarlink(globals, "SecurityType_CATS_TIGERS_AND_LIONS", Swig_var_SecurityType_CATS_TIGERS_AND_LIONS_get, Swig_var_SecurityType_CATS_TIGERS_AND_LIONS_set);
  SWIG_addvarlink(globals, "SecurityType_WILDCARD", Swig_var_SecurityType_WILDCARD_get, Swig_var_SecurityType_WILDCARD_set);
  SWIG_addvarlink(globals, "SecurityType_CONVERTIBLE_BOND", Swig_var_SecurityType_CONVERTIBLE_BOND_get, Swig_var_SecurityType_CONVERTIBLE_BOND_set);
  SWIG_addvarlink(globals, "SecurityType_IOETTE_MORTGAGE", Swig_var_SecurityType_IOETTE_MORTGAGE_get, Swig_var_SecurityType_IOETTE_MORTGAGE_set);
  SWIG_addvarlink(globals, "SecurityType_VARIABLE_RATE_DEMAND_NOTE", Swig_var_SecurityType_VARIABLE_RATE_DEMAND_NOTE_get, Swig_var_SecurityType_VARIABLE_RATE_DEMAND_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_PLAZOS_FIJOS", Swig_var_SecurityType_PLAZOS_FIJOS_get, Swig_var_SecurityType_PLAZOS_FIJOS_set);
  SWIG_addvarlink(globals, "SecurityType_PROMISSORY_NOTE", Swig_var_SecurityType_PROMISSORY_NOTE_get, Swig_var_SecurityType_PROMISSORY_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_OVERNIGHT", Swig_var_SecurityType_OVERNIGHT_get, Swig_var_SecurityType_OVERNIGHT_set);
  SWIG_addvarlink(globals, "SecurityType_MEDIUM_TERM_NOTES", Swig_var_SecurityType_MEDIUM_TERM_NOTES_get, Swig_var_SecurityType_MEDIUM_TERM_NOTES_set);
  SWIG_addvarlink(globals, "SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER", Swig_var_SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_get, Swig_var_SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_set);
  SWIG_addvarlink(globals, "SecurityType_AMENDED", Swig_var_SecurityType_AMENDED_get, Swig_var_SecurityType_AMENDED_set);
  SWIG_addvarlink(globals, "SecurityType_BRIDGE_LOAN", Swig_var_SecurityType_BRIDGE_LOAN_get, Swig_var_SecurityType_BRIDGE_LOAN_set);
  SWIG_addvarlink(globals, "SecurityType_LETTER_OF_CREDIT", Swig_var_SecurityType_LETTER_OF_CREDIT_get, Swig_var_SecurityType_LETTER_OF_CREDIT_set);
  SWIG_addvarlink(globals, "SecurityType_SWING_LINE_FACILITY", Swig_var_SecurityType_SWING_LINE_FACILITY_get, Swig_var_SecurityType_SWING_LINE_FACILITY_set);
  SWIG_addvarlink(globals, "SecurityType_DEBTOR_IN_POSSESSION", Swig_var_SecurityType_DEBTOR_IN_POSSESSION_get, Swig_var_SecurityType_DEBTOR_IN_POSSESSION_set);
  SWIG_addvarlink(globals, "SecurityType_DEFAULTED", Swig_var_SecurityType_DEFAULTED_get, Swig_var_SecurityType_DEFAULTED_set);
  SWIG_addvarlink(globals, "SecurityType_WITHDRAWN", Swig_var_SecurityType_WITHDRAWN_get, Swig_var_SecurityType_WITHDRAWN_set);
  SWIG_addvarlink(globals, "SecurityType_LIQUIDITY_NOTE", Swig_var_SecurityType_LIQUIDITY_NOTE_get, Swig_var_SecurityType_LIQUIDITY_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_MATURED", Swig_var_SecurityType_MATURED_get, Swig_var_SecurityType_MATURED_set);
  SWIG_addvarlink(globals, "SecurityType_DEPOSIT_NOTES", Swig_var_SecurityType_DEPOSIT_NOTES_get, Swig_var_SecurityType_DEPOSIT_NOTES_set);
  SWIG_addvarlink(globals, "SecurityType_RETIRED", Swig_var_SecurityType_RETIRED_get, Swig_var_SecurityType_RETIRED_set);
  SWIG_addvarlink(globals, "SecurityType_BANK_NOTES", Swig_var_SecurityType_BANK_NOTES_get, Swig_var_SecurityType_BANK_NOTES_set);
  SWIG_addvarlink(globals, "SecurityType_BILL_OF_EXCHANGES", Swig_var_SecurityType_BILL_OF_EXCHANGES_get, Swig_var_SecurityType_BILL_OF_EXCHANGES_set);
  SWIG_addvarlink(globals, "SecurityType_CALL_LOANS", Swig_var_SecurityType_CALL_LOANS_get, Swig_var_SecurityType_CALL_LOANS_set);
  SWIG_addvarlink(globals, "SecurityType_REPLACED", Swig_var_SecurityType_REPLACED_get, Swig_var_SecurityType_REPLACED_set);
  SWIG_addvarlink(globals, "SecurityType_MANDATORY_TENDER", Swig_var_SecurityType_MANDATORY_TENDER_get, Swig_var_SecurityType_MANDATORY_TENDER_set);
  SWIG_addvarlink(globals, "SecurityType_REVOLVER", Swig_var_SecurityType_REVOLVER_get, Swig_var_SecurityType_REVOLVER_set);
  SWIG_addvarlink(globals, "SecurityType_SHORT_TERM_LOAN_NOTE", Swig_var_SecurityType_SHORT_TERM_LOAN_NOTE_get, Swig_var_SecurityType_SHORT_TERM_LOAN_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_TO_BE_ANNOUNCED", Swig_var_SecurityType_TO_BE_ANNOUNCED_get, Swig_var_SecurityType_TO_BE_ANNOUNCED_set);
  SWIG_addvarlink(globals, "SecurityType_OTHER_ANTICIPATION_NOTES", Swig_var_SecurityType_OTHER_ANTICIPATION_NOTES_get, Swig_var_SecurityType_OTHER_ANTICIPATION_NOTES_set);
  SWIG_addvarlink(globals, "SecurityType_CERTIFICATE_OF_PARTICIPATION", Swig_var_SecurityType_CERTIFICATE_OF_PARTICIPATION_get, Swig_var_SecurityType_CERTIFICATE_OF_PARTICIPATION_set);
  SWIG_addvarlink(globals, "SecurityType_MORTGAGE_BACKED_SECURITIES", Swig_var_SecurityType_MORTGAGE_BACKED_SECURITIES_get, Swig_var_SecurityType_MORTGAGE_BACKED_SECURITIES_set);
  SWIG_addvarlink(globals, "SecurityType_REVENUE_BONDS", Swig_var_SecurityType_REVENUE_BONDS_get, Swig_var_SecurityType_REVENUE_BONDS_set);
  SWIG_addvarlink(globals, "SecurityType_SPECIAL_ASSESSMENT", Swig_var_SecurityType_SPECIAL_ASSESSMENT_get, Swig_var_SecurityType_SPECIAL_ASSESSMENT_set);
  SWIG_addvarlink(globals, "SecurityType_SPECIAL_OBLIGATION", Swig_var_SecurityType_SPECIAL_OBLIGATION_get, Swig_var_SecurityType_SPECIAL_OBLIGATION_set);
  SWIG_addvarlink(globals, "SecurityType_SPECIAL_TAX", Swig_var_SecurityType_SPECIAL_TAX_get, Swig_var_SecurityType_SPECIAL_TAX_set);
  SWIG_addvarlink(globals, "SecurityType_TAX_ANTICIPATION_NOTE", Swig_var_SecurityType_TAX_ANTICIPATION_NOTE_get, Swig_var_SecurityType_TAX_ANTICIPATION_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_TAX_ALLOCATION", Swig_var_SecurityType_TAX_ALLOCATION_get, Swig_var_SecurityType_TAX_ALLOCATION_set);
  SWIG_addvarlink(globals, "SecurityType_CERTIFICATE_OF_OBLIGATION", Swig_var_SecurityType_CERTIFICATE_OF_OBLIGATION_get, Swig_var_SecurityType_CERTIFICATE_OF_OBLIGATION_set);
  SWIG_addvarlink(globals, "SecurityType_GENERAL_OBLIGATION_BONDS", Swig_var_SecurityType_GENERAL_OBLIGATION_BONDS_get, Swig_var_SecurityType_GENERAL_OBLIGATION_BONDS_set);
  SWIG_addvarlink(globals, "SecurityType_MULTILEG_INSTRUMENT", Swig_var_SecurityType_MULTILEG_INSTRUMENT_get, Swig_var_SecurityType_MULTILEG_INSTRUMENT_set);
  SWIG_addvarlink(globals, "SecurityType_TAX_REVENUE_ANTICIPATION_NOTE", Swig_var_SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_get, Swig_var_SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_EXTENDED_COMM_NOTE", Swig_var_SecurityType_EXTENDED_COMM_NOTE_get, Swig_var_SecurityType_EXTENDED_COMM_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_AGENCY_POOLS", Swig_var_SecurityType_AGENCY_POOLS_get, Swig_var_SecurityType_AGENCY_POOLS_set);
  SWIG_addvarlink(globals, "SecurityType_ASSET_BACKED_SECURITIES", Swig_var_SecurityType_ASSET_BACKED_SECURITIES_get, Swig_var_SecurityType_ASSET_BACKED_SECURITIES_set);
  SWIG_addvarlink(globals, "SecurityType_CORP", Swig_var_SecurityType_CORP_get, Swig_var_SecurityType_CORP_set);
  SWIG_addvarlink(globals, "SecurityType_REVENUE_ANTICIPATION_NOTE", Swig_var_SecurityType_REVENUE_ANTICIPATION_NOTE_get, Swig_var_SecurityType_REVENUE_ANTICIPATION_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_REVOLVER_LOAN", Swig_var_SecurityType_REVOLVER_LOAN_get, Swig_var_SecurityType_REVOLVER_LOAN_set);
  SWIG_addvarlink(globals, "SecurityType_FEDERAL_AGENCY_COUPON", Swig_var_SecurityType_FEDERAL_AGENCY_COUPON_get, Swig_var_SecurityType_FEDERAL_AGENCY_COUPON_set);
  SWIG_addvarlink(globals, "SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE", Swig_var_SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_get, Swig_var_SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_PRIVATE_EXPORT_FUNDING", Swig_var_SecurityType_PRIVATE_EXPORT_FUNDING_get, Swig_var_SecurityType_PRIVATE_EXPORT_FUNDING_set);
  SWIG_addvarlink(globals, "SecurityType_DUAL_CURRENCY", Swig_var_SecurityType_DUAL_CURRENCY_get, Swig_var_SecurityType_DUAL_CURRENCY_set);
  SWIG_addvarlink(globals, "SecurityType_INDEXED_LINKED", Swig_var_SecurityType_INDEXED_LINKED_get, Swig_var_SecurityType_INDEXED_LINKED_set);
  SWIG_addvarlink(globals, "SecurityType_YANKEE_CORPORATE_BOND", Swig_var_SecurityType_YANKEE_CORPORATE_BOND_get, Swig_var_SecurityType_YANKEE_CORPORATE_BOND_set);
  SWIG_addvarlink(globals, "SecurityType_BRADY_BOND", Swig_var_SecurityType_BRADY_BOND_get, Swig_var_SecurityType_BRADY_BOND_set);
  SWIG_addvarlink(globals, "SecurityType_US_TREASURY_BOND", Swig_var_SecurityType_US_TREASURY_BOND_get, Swig_var_SecurityType_US_TREASURY_BOND_set);
  SWIG_addvarlink(globals, "SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE", Swig_var_SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE_get, Swig_var_SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES", Swig_var_SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_get, Swig_var_SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_set);
  SWIG_addvarlink(globals, "SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE", Swig_var_SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE_get, Swig_var_SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE", Swig_var_SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE_get, Swig_var_SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_US_TREASURY_NOTE_OLD", Swig_var_SecurityType_US_TREASURY_NOTE_OLD_get, Swig_var_SecurityType_US_TREASURY_NOTE_OLD_set);
  SWIG_addvarlink(globals, "SecurityType_TERM_LOAN", Swig_var_SecurityType_TERM_LOAN_get, Swig_var_SecurityType_TERM_LOAN_set);
  SWIG_addvarlink(globals, "SecurityType_STRUCTURED_NOTES", Swig_var_SecurityType_STRUCTURED_NOTES_get, Swig_var_SecurityType_STRUCTURED_NOTES_set);
  SWIG_addvarlink(globals, "SecurityType_EURO_SUPRANATIONAL_COUPONS", Swig_var_SecurityType_EURO_SUPRANATIONAL_COUPONS_get, Swig_var_SecurityType_EURO_SUPRANATIONAL_COUPONS_set);
  SWIG_addvarlink(globals, "SecurityType_USD_SUPRANATIONAL_COUPONS", Swig_var_SecurityType_USD_SUPRANATIONAL_COUPONS_get, Swig_var_SecurityType_USD_SUPRANATIONAL_COUPONS_set);
  SWIG_addvarlink(globals, "SecurityType_EURO_CORPORATE_BOND", Swig_var_SecurityType_EURO_CORPORATE_BOND_get, Swig_var_SecurityType_EURO_CORPORATE_BOND_set);
  SWIG_addvarlink(globals, "SecurityType_EURO_SOVEREIGNS", Swig_var_SecurityType_EURO_SOVEREIGNS_get, Swig_var_SecurityType_EURO_SOVEREIGNS_set);
  SWIG_addvarlink(globals, "SecurityType_US_TREASURY_NOTE", Swig_var_SecurityType_US_TREASURY_NOTE_get, Swig_var_SecurityType_US_TREASURY_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_US_TREASURY_BILL", Swig_var_SecurityType_US_TREASURY_BILL_get, Swig_var_SecurityType_US_TREASURY_BILL_set);
  SWIG_addvarlink(globals, "SecurityType_REPURCHASE", Swig_var_SecurityType_REPURCHASE_get, Swig_var_SecurityType_REPURCHASE_set);
  SWIG_addvarlink(globals, "SecurityType_FORWARD", Swig_var_SecurityType_FORWARD_get, Swig_var_SecurityType_FORWARD_set);
  SWIG_addvarlink(globals, "SecurityType_BUY_SELLBACK", Swig_var_SecurityType_BUY_SELLBACK_get, Swig_var_SecurityType_BUY_SELLBACK_set);
  SWIG_addvarlink(globals, "SecurityType_SECURITIES_LOAN", Swig_var_SecurityType_SECURITIES_LOAN_get, Swig_var_SecurityType_SECURITIES_LOAN_set);
  SWIG_addvarlink(globals, "SecurityType_SECURITIES_PLEDGE", Swig_var_SecurityType_SECURITIES_PLEDGE_get, Swig_var_SecurityType_SECURITIES_PLEDGE_set);
  SWIG_addvarlink(globals, "SecurityType_EURO_CERTIFICATE_OF_DEPOSIT", Swig_var_SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_get, Swig_var_SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_set);
  SWIG_addvarlink(globals, "SecurityType_EURO_COMMERCIAL_PAPER", Swig_var_SecurityType_EURO_COMMERCIAL_PAPER_get, Swig_var_SecurityType_EURO_COMMERCIAL_PAPER_set);
  SWIG_addvarlink(globals, "SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT", Swig_var_SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_get, Swig_var_SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_set);
  SWIG_addvarlink(globals, "SecurityType_PFANDBRIEFE", Swig_var_SecurityType_PFANDBRIEFE_get, Swig_var_SecurityType_PFANDBRIEFE_set);
  SWIG_addvarlink(globals, "SecurityType_OPTIONS_ON_FUTURES", Swig_var_SecurityType_OPTIONS_ON_FUTURES_get, Swig_var_SecurityType_OPTIONS_ON_FUTURES_set);
  SWIG_addvarlink(globals, "SecurityType_OPTIONS_ON_PHYSICAL", Swig_var_SecurityType_OPTIONS_ON_PHYSICAL_get, Swig_var_SecurityType_OPTIONS_ON_PHYSICAL_set);
  SWIG_addvarlink(globals, "SecurityType_WILDCARD_ENTRY", Swig_var_SecurityType_WILDCARD_ENTRY_get, Swig_var_SecurityType_WILDCARD_ENTRY_set);
  SWIG_addvarlink(globals, "SecurityType_CASH", Swig_var_SecurityType_CASH_get, Swig_var_SecurityType_CASH_set);
  SWIG_addvarlink(globals, "SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES", Swig_var_SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES_get, Swig_var_SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES_set);
  SWIG_addvarlink(globals, "SecurityType_US_CORPORATE_FLOATING_RATE_NOTES", Swig_var_SecurityType_US_CORPORATE_FLOATING_RATE_NOTES_get, Swig_var_SecurityType_US_CORPORATE_FLOATING_RATE_NOTES_set);
  SWIG_addvarlink(globals, "SecurityType_CREDIT_DEFAULT_SWAP", Swig_var_SecurityType_CREDIT_DEFAULT_SWAP_get, Swig_var_SecurityType_CREDIT_DEFAULT_SWAP_set);
  SWIG_addvarlink(globals, "SecurityType_INTEREST_RATE_SWAP", Swig_var_SecurityType_INTEREST_RATE_SWAP_get, Swig_var_SecurityType_INTEREST_RATE_SWAP_set);
  SWIG_addvarlink(globals, "SecurityType_OPTIONS_ON_COMBO", Swig_var_SecurityType_OPTIONS_ON_COMBO_get, Swig_var_SecurityType_OPTIONS_ON_COMBO_set);
  SWIG_addvarlink(globals, "SecurityType_CANADIAN_TREASURY_NOTES", Swig_var_SecurityType_CANADIAN_TREASURY_NOTES_get, Swig_var_SecurityType_CANADIAN_TREASURY_NOTES_set);
  SWIG_addvarlink(globals, "SecurityType_CANADIAN_TREASURY_BILLS", Swig_var_SecurityType_CANADIAN_TREASURY_BILLS_get, Swig_var_SecurityType_CANADIAN_TREASURY_BILLS_set);
  SWIG_addvarlink(globals, "SecurityType_CANADIAN_PROVINCIAL_BONDS", Swig_var_SecurityType_CANADIAN_PROVINCIAL_BONDS_get, Swig_var_SecurityType_CANADIAN_PROVINCIAL_BONDS_set);
  SWIG_addvarlink(globals, "SecurityType_TREASURY_BILL", Swig_var_SecurityType_TREASURY_BILL_get, Swig_var_SecurityType_TREASURY_BILL_set);
  SWIG_addvarlink(globals, "SecurityType_BANK_DEPOSITORY_NOTE", Swig_var_SecurityType_BANK_DEPOSITORY_NOTE_get, Swig_var_SecurityType_BANK_DEPOSITORY_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_CANADIAN_MONEY_MARKETS", Swig_var_SecurityType_CANADIAN_MONEY_MARKETS_get, Swig_var_SecurityType_CANADIAN_MONEY_MARKETS_set);
  SWIG_addvarlink(globals, "SecurityType_SECURED_LIQUIDITY_NOTE", Swig_var_SecurityType_SECURED_LIQUIDITY_NOTE_get, Swig_var_SecurityType_SECURED_LIQUIDITY_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_TERM_LIQUIDITY_NOTE", Swig_var_SecurityType_TERM_LIQUIDITY_NOTE_get, Swig_var_SecurityType_TERM_LIQUIDITY_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_CANADIAN_MORTGAGE_BONDS", Swig_var_SecurityType_CANADIAN_MORTGAGE_BONDS_get, Swig_var_SecurityType_CANADIAN_MORTGAGE_BONDS_set);
  SWIG_addvarlink(globals, "SecurityType_TAXABLE_MUNICIPAL_CP", Swig_var_SecurityType_TAXABLE_MUNICIPAL_CP_get, Swig_var_SecurityType_TAXABLE_MUNICIPAL_CP_set);
  SWIG_addvarlink(globals, "SecurityType_OFFSHORE_ISSUED_CHINESE_YUAN_CORPORATE_BOND", Swig_var_SecurityType_OFFSHORE_ISSUED_CHINESE_YUAN_CORPORATE_BOND_get, Swig_var_SecurityType_OFFSHORE_ISSUED_CHINESE_YUAN_CORPORATE_BOND_set);
  SWIG_addvarlink(globals, "SecurityType_PREFERRED_CORPORATE_BOND", Swig_var_SecurityType_PREFERRED_CORPORATE_BOND_get, Swig_var_SecurityType_PREFERRED_CORPORATE_BOND_set);
  SWIG_addvarlink(globals, "SecurityType_NON_DELIVERABLE_FORWARD", Swig_var_SecurityType_NON_DELIVERABLE_FORWARD_get, Swig_var_SecurityType_NON_DELIVERABLE_FORWARD_set);
  SWIG_addvarlink(globals, "SecurityType_FX_SPOT", Swig_var_SecurityType_FX_SPOT_get, Swig_var_SecurityType_FX_SPOT_set);
  SWIG_addvarlink(globals, "SecurityType_FX_FORWARD", Swig_var_SecurityType_FX_FORWARD_get, Swig_var_SecurityType_FX_FORWARD_set);
  SWIG_addvarlink(globals, "SecurityType_FX_SWAP", Swig_var_SecurityType_FX_SWAP_get, Swig_var_SecurityType_FX_SWAP_set);
  SWIG_addvarlink(globals, "SecurityType_NON_DELIVERABLE_SWAP", Swig_var_SecurityType_NON_DELIVERABLE_SWAP_get, Swig_var_SecurityType_NON_DELIVERABLE_SWAP_set);
  SWIG_addvarlink(globals, "SecurityType_FX_BANK_NOTE", Swig_var_SecurityType_FX_BANK_NOTE_get, Swig_var_SecurityType_FX_BANK_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_FOREIGN_CURRENCY_DISCOUNT_NOTE", Swig_var_SecurityType_FOREIGN_CURRENCY_DISCOUNT_NOTE_get, Swig_var_SecurityType_FOREIGN_CURRENCY_DISCOUNT_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_CAP", Swig_var_SecurityType_CAP_get, Swig_var_SecurityType_CAP_set);
  SWIG_addvarlink(globals, "SecurityType_COLLAR", Swig_var_SecurityType_COLLAR_get, Swig_var_SecurityType_COLLAR_set);
  SWIG_addvarlink(globals, "SecurityType_COMMODITY_SWAP", Swig_var_SecurityType_COMMODITY_SWAP_get, Swig_var_SecurityType_COMMODITY_SWAP_set);
  SWIG_addvarlink(globals, "SecurityType_EXOTIC", Swig_var_SecurityType_EXOTIC_get, Swig_var_SecurityType_EXOTIC_set);
  SWIG_addvarlink(globals, "SecurityType_FLOOR", Swig_var_SecurityType_FLOOR_get, Swig_var_SecurityType_FLOOR_set);
  SWIG_addvarlink(globals, "SecurityType_FRA", Swig_var_SecurityType_FRA_get, Swig_var_SecurityType_FRA_set);
  SWIG_addvarlink(globals, "SecurityType_DERIVATIVE_FORWARD", Swig_var_SecurityType_DERIVATIVE_FORWARD_get, Swig_var_SecurityType_DERIVATIVE_FORWARD_set);
  SWIG_addvarlink(globals, "SecurityType_TOTAL_RETURN_SWAP", Swig_var_SecurityType_TOTAL_RETURN_SWAP_get, Swig_var_SecurityType_TOTAL_RETURN_SWAP_set);
  SWIG_addvarlink(globals, "SecurityType_LOAN_LEASE", Swig_var_SecurityType_LOAN_LEASE_get, Swig_var_SecurityType_LOAN_LEASE_set);
  SWIG_addvarlink(globals, "SecurityType_SPOT_FORWARD", Swig_var_SecurityType_SPOT_FORWARD_get, Swig_var_SecurityType_SPOT_FORWARD_set);
  SWIG_addvarlink(globals, "SecurityType_SWAP_OPTION", Swig_var_SecurityType_SWAP_OPTION_get, Swig_var_SecurityType_SWAP_OPTION_set);
  SWIG_addvarlink(globals, "SecurityType_TRANSMISSION", Swig_var_SecurityType_TRANSMISSION_get, Swig_var_SecurityType_TRANSMISSION_set);
  SWIG_addvarlink(globals, "SecurityType_INDEX", Swig_var_SecurityType_INDEX_get, Swig_var_SecurityType_INDEX_set);
  SWIG_addvarlink(globals, "SecurityType_BOND_BASKET", Swig_var_SecurityType_BOND_BASKET_get, Swig_var_SecurityType_BOND_BASKET_set);
  SWIG_addvarlink(globals, "SecurityType_CONTRACT_FOR_DIFFERENCE", Swig_var_SecurityType_CONTRACT_FOR_DIFFERENCE_get, Swig_var_SecurityType_CONTRACT_FOR_DIFFERENCE_set);
  SWIG_addvarlink(globals, "SecurityType_CORRELATION_SWAP", Swig_var_SecurityType_CORRELATION_SWAP_get, Swig_var_SecurityType_CORRELATION_SWAP_set);
  SWIG_addvarlink(globals, "SecurityType_DIVIEND_SWAP", Swig_var_SecurityType_DIVIEND_SWAP_get, Swig_var_SecurityType_DIVIEND_SWAP_set);
  SWIG_addvarlink(globals, "SecurityType_EQUITY_BASKET", Swig_var_SecurityType_EQUITY_BASKET_get, Swig_var_SecurityType_EQUITY_BASKET_set);
  SWIG_addvarlink(globals, "SecurityType_EQUITY_FORWARD", Swig_var_SecurityType_EQUITY_FORWARD_get, Swig_var_SecurityType_EQUITY_FORWARD_set);
  SWIG_addvarlink(globals, "SecurityType_RETURN_SWAP", Swig_var_SecurityType_RETURN_SWAP_get, Swig_var_SecurityType_RETURN_SWAP_set);
  SWIG_addvarlink(globals, "SecurityType_VARIANCE_SWAP", Swig_var_SecurityType_VARIANCE_SWAP_get, Swig_var_SecurityType_VARIANCE_SWAP_set);
  SWIG_addvarlink(globals, "SecurityType_PORTFOLIO_SWAPS", Swig_var_SecurityType_PORTFOLIO_SWAPS_get, Swig_var_SecurityType_PORTFOLIO_SWAPS_set);
  SWIG_addvarlink(globals, "SecurityType_FUTURES_ON_A_SWAP", Swig_var_SecurityType_FUTURES_ON_A_SWAP_get, Swig_var_SecurityType_FUTURES_ON_A_SWAP_set);
  SWIG_addvarlink(globals, "SecurityType_FORWARDS_ON_A_SWAP", Swig_var_SecurityType_FORWARDS_ON_A_SWAP_get, Swig_var_SecurityType_FORWARDS_ON_A_SWAP_set);
  SWIG_addvarlink(globals, "SecurityType_FORWARD_FREIGHT_AGREEMENT", Swig_var_SecurityType_FORWARD_FREIGHT_AGREEMENT_get, Swig_var_SecurityType_FORWARD_FREIGHT_AGREEMENT_set);
  SWIG_addvarlink(globals, "SecurityType_SPREAD_BETTING", Swig_var_SecurityType_SPREAD_BETTING_get, Swig_var_SecurityType_SPREAD_BETTING_set);
  SWIG_addvarlink(globals, "SecurityType_EXCHANGE_TRADED_COMMODITY", Swig_var_SecurityType_EXCHANGE_TRADED_COMMODITY_get, Swig_var_SecurityType_EXCHANGE_TRADED_COMMODITY_set);
  SWIG_addvarlink(globals, "SecurityType_DEPOSITORY_RECEIPTS", Swig_var_SecurityType_DEPOSITORY_RECEIPTS_get, Swig_var_SecurityType_DEPOSITORY_RECEIPTS_set);
  SWIG_addvarlink(globals, "SecurityType_DELIVERY_VERSUS_PLEDGE", Swig_var_SecurityType_DELIVERY_VERSUS_PLEDGE_get, Swig_var_SecurityType_DELIVERY_VERSUS_PLEDGE_set);
  SWIG_addvarlink(globals, "SecurityType_COLLATERAL_BASKET", Swig_var_SecurityType_COLLATERAL_BASKET_get, Swig_var_SecurityType_COLLATERAL_BASKET_set);
  SWIG_addvarlink(globals, "SecurityType_STRUCTURED_FINANCE_PRODUCT", Swig_var_SecurityType_STRUCTURED_FINANCE_PRODUCT_get, Swig_var_SecurityType_STRUCTURED_FINANCE_PRODUCT_set);
  SWIG_addvarlink(globals, "SecurityType_MARGIN_LOAN", Swig_var_SecurityType_MARGIN_LOAN_get, Swig_var_SecurityType_MARGIN_LOAN_set);
  SWIG_addvarlink(globals, "SecurityType_OFFSHORE_ISSUED_CHINESE_YUAN_SOVEREIGN_BOND", Swig_var_SecurityType_OFFSHORE_ISSUED_CHINESE_YUAN_SOVEREIGN_BOND_get, Swig_var_SecurityType_OFFSHORE_ISSUED_CHINESE_YUAN_SOVEREIGN_BOND_set);
  SWIG_addvarlink(globals, "SecurityType_SOVEREIGN_BOND", Swig_var_SecurityType_SOVEREIGN_BOND_get, Swig_var_SecurityType_SOVEREIGN_BOND_set);
  SWIG_addvarlink(globals, "SecurityType_US_TREASURY_FLOATING_RATE_NOTE", Swig_var_SecurityType_US_TREASURY_FLOATING_RATE_NOTE_get, Swig_var_SecurityType_US_TREASURY_FLOATING_RATE_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_BANK_ACCEPTED_BILL", Swig_var_SecurityType_BANK_ACCEPTED_BILL_get, Swig_var_SecurityType_BANK_ACCEPTED_BILL_set);
  SWIG_addvarlink(globals, "SecurityType_SHORT_TERM_BANK_NOTE", Swig_var_SecurityType_SHORT_TERM_BANK_NOTE_get, Swig_var_SecurityType_SHORT_TERM_BANK_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_CALLABLE_COMMERCIAL_PAPER", Swig_var_SecurityType_CALLABLE_COMMERCIAL_PAPER_get, Swig_var_SecurityType_CALLABLE_COMMERCIAL_PAPER_set);
  SWIG_addvarlink(globals, "SecurityType_COMMERCIAL_NOTE", Swig_var_SecurityType_COMMERCIAL_NOTE_get, Swig_var_SecurityType_COMMERCIAL_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_INTEREST_BEARING_COMMERCIAL_PAPER", Swig_var_SecurityType_INTEREST_BEARING_COMMERCIAL_PAPER_get, Swig_var_SecurityType_INTEREST_BEARING_COMMERCIAL_PAPER_set);
  SWIG_addvarlink(globals, "SecurityType_EURO_MEDIUM_TERM_NOTE", Swig_var_SecurityType_EURO_MEDIUM_TERM_NOTE_get, Swig_var_SecurityType_EURO_MEDIUM_TERM_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_EURO_NEGOTIABLE_COMMERCIAL_PAPER", Swig_var_SecurityType_EURO_NEGOTIABLE_COMMERCIAL_PAPER_get, Swig_var_SecurityType_EURO_NEGOTIABLE_COMMERCIAL_PAPER_set);
  SWIG_addvarlink(globals, "SecurityType_EURO_STRUCTURED_LIQUIDITY_NOTE", Swig_var_SecurityType_EURO_STRUCTURED_LIQUIDITY_NOTE_get, Swig_var_SecurityType_EURO_STRUCTURED_LIQUIDITY_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_EURO_TIME_DEPOSIT", Swig_var_SecurityType_EURO_TIME_DEPOSIT_get, Swig_var_SecurityType_EURO_TIME_DEPOSIT_set);
  SWIG_addvarlink(globals, "SecurityType_JUMBO_CERTIFICATE_OF_DEPOSIT", Swig_var_SecurityType_JUMBO_CERTIFICATE_OF_DEPOSIT_get, Swig_var_SecurityType_JUMBO_CERTIFICATE_OF_DEPOSIT_set);
  SWIG_addvarlink(globals, "SecurityType_MONEY_MARKET_FUND", Swig_var_SecurityType_MONEY_MARKET_FUND_get, Swig_var_SecurityType_MONEY_MARKET_FUND_set);
  SWIG_addvarlink(globals, "SecurityType_MASTER_NOTE", Swig_var_SecurityType_MASTER_NOTE_get, Swig_var_SecurityType_MASTER_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_NEGOTIABLE_CERTIFICATE_OF_DEPOSIT", Swig_var_SecurityType_NEGOTIABLE_CERTIFICATE_OF_DEPOSIT_get, Swig_var_SecurityType_NEGOTIABLE_CERTIFICATE_OF_DEPOSIT_set);
  SWIG_addvarlink(globals, "SecurityType_NEGOTIABLE_COMMERCIAL_PAPER", Swig_var_SecurityType_NEGOTIABLE_COMMERCIAL_PAPER_get, Swig_var_SecurityType_NEGOTIABLE_COMMERCIAL_PAPER_set);
  SWIG_addvarlink(globals, "SecurityType_RETAIL_CERTIFICATE_OF_DEPOSIT", Swig_var_SecurityType_RETAIL_CERTIFICATE_OF_DEPOSIT_get, Swig_var_SecurityType_RETAIL_CERTIFICATE_OF_DEPOSIT_set);
  SWIG_addvarlink(globals, "SecurityType_TERM_DEPOSIT_RECEIPT", Swig_var_SecurityType_TERM_DEPOSIT_RECEIPT_get, Swig_var_SecurityType_TERM_DEPOSIT_RECEIPT_set);
  SWIG_addvarlink(globals, "SecurityType_PFANDBRIEF", Swig_var_SecurityType_PFANDBRIEF_get, Swig_var_SecurityType_PFANDBRIEF_set);
  SWIG_addvarlink(globals, "SecurityType_MUNICIPAL_INTEREST_BEARING_COMMERCIAL_PAPER", Swig_var_SecurityType_MUNICIPAL_INTEREST_BEARING_COMMERCIAL_PAPER_get, Swig_var_SecurityType_MUNICIPAL_INTEREST_BEARING_COMMERCIAL_PAPER_set);
  SWIG_addvarlink(globals, "SecurityType_TAXABLE_MUNICIPAL_BOND", Swig_var_SecurityType_TAXABLE_MUNICIPAL_BOND_get, Swig_var_SecurityType_TAXABLE_MUNICIPAL_BOND_set);
  SWIG_addvarlink(globals, "SecurityType_VARIABLE_RATE_DEMAND_OBLIGATION", Swig_var_SecurityType_VARIABLE_RATE_DEMAND_OBLIGATION_get, Swig_var_SecurityType_VARIABLE_RATE_DEMAND_OBLIGATION_set);
  SWIG_addvarlink(globals, "SecurityType_OTHER", Swig_var_SecurityType_OTHER_get, Swig_var_SecurityType_OTHER_set);
  SWIG_addvarlink(globals, "SecurityType_EXCHANGE_TRADED_NOTE", Swig_var_SecurityType_EXCHANGE_TRADED_NOTE_get, Swig_var_SecurityType_EXCHANGE_TRADED_NOTE_set);
  SWIG_addvarlink(globals, "SecurityType_SECURITIZED_DERIVATIVE", Swig_var_SecurityType_SECURITIZED_DERIVATIVE_get, Swig_var_SecurityType_SECURITIZED_DERIVATIVE_set);
  SWIG_addvarlink(globals, "SecurityType_EXCHANGE_TRADED_FUND", Swig_var_SecurityType_EXCHANGE_TRADED_FUND_get, Swig_var_SecurityType_EXCHANGE_TRADED_FUND_set);
  SWIG_addvarlink(globals, "SecurityType_DIGITAL_ASSET", Swig_var_SecurityType_DIGITAL_ASSET_get, Swig_var_SecurityType_DIGITAL_ASSET_set);
  SWIG_addvarlink(globals, "StandInstDbType_OTHER", Swig_var_StandInstDbType_OTHER_get, Swig_var_StandInstDbType_OTHER_set);
  SWIG_addvarlink(globals, "StandInstDbType_DTCSID", Swig_var_StandInstDbType_DTCSID_get, Swig_var_StandInstDbType_DTCSID_set);
  SWIG_addvarlink(globals, "StandInstDbType_THOMSON_ALERT", Swig_var_StandInstDbType_THOMSON_ALERT_get, Swig_var_StandInstDbType_THOMSON_ALERT_set);
  SWIG_addvarlink(globals, "StandInstDbType_A_GLOBAL_CUSTODIAN", Swig_var_StandInstDbType_A_GLOBAL_CUSTODIAN_get, Swig_var_StandInstDbType_A_GLOBAL_CUSTODIAN_set);
  SWIG_addvarlink(globals, "StandInstDbType_ACCOUNT_NET", Swig_var_StandInstDbType_ACCOUNT_NET_get, Swig_var_StandInstDbType_ACCOUNT_NET_set);
  SWIG_addvarlink(globals, "SettlDeliveryType_FREE", Swig_var_SettlDeliveryType_FREE_get, Swig_var_SettlDeliveryType_FREE_set);
  SWIG_addvarlink(globals, "SettlDeliveryType_VERSUS", Swig_var_SettlDeliveryType_VERSUS_get, Swig_var_SettlDeliveryType_VERSUS_set);
  SWIG_addvarlink(globals, "SettlDeliveryType_TRI_PARTY", Swig_var_SettlDeliveryType_TRI_PARTY_get, Swig_var_SettlDeliveryType_TRI_PARTY_set);
  SWIG_addvarlink(globals, "SettlDeliveryType_HOLD_IN_CUSTODY", Swig_var_SettlDeliveryType_HOLD_IN_CUSTODY_get, Swig_var_SettlDeliveryType_HOLD_IN_CUSTODY_set);
  SWIG_addvarlink(globals, "AllocLinkType_FX_NETTING", Swig_var_AllocLinkType_FX_NETTING_get, Swig_var_AllocLinkType_FX_NETTING_set);
  SWIG_addvarlink(globals, "AllocLinkType_FX_SWAP", Swig_var_AllocLinkType_FX_SWAP_get, Swig_var_AllocLinkType_FX_SWAP_set);
  SWIG_addvarlink(globals, "PutOrCall_PUT", Swig_var_PutOrCall_PUT_get, Swig_var_PutOrCall_PUT_set);
  SWIG_addvarlink(globals, "PutOrCall_CALL", Swig_var_PutOrCall_CALL_get, Swig_var_PutOrCall_CALL_set);
  SWIG_addvarlink(globals, "PutOrCall_OTHER", Swig_var_PutOrCall_OTHER_get, Swig_var_PutOrCall_OTHER_set);
  SWIG_addvarlink(globals, "PutOrCall_CHOOSER", Swig_var_PutOrCall_CHOOSER_get, Swig_var_PutOrCall_CHOOSER_set);
  SWIG_addvarlink(globals, "CoveredOrUncovered_COVERED", Swig_var_CoveredOrUncovered_COVERED_get, Swig_var_CoveredOrUncovered_COVERED_set);
  SWIG_addvarlink(globals, "CoveredOrUncovered_UNCOVERED", Swig_var_CoveredOrUncovered_UNCOVERED_get, Swig_var_CoveredOrUncovered_UNCOVERED_set);
  SWIG_addvarlink(globals, "CustomerOrFirm_CUSTOMER", Swig_var_CustomerOrFirm_CUSTOMER_get, Swig_var_CustomerOrFirm_CUSTOMER_set);
  SWIG_addvarlink(globals, "CustomerOrFirm_FIRM", Swig_var_CustomerOrFirm_FIRM_get, Swig_var_CustomerOrFirm_FIRM_set);
  SWIG_addvarlink(globals, "NotifyBrokerOfCredit_NO", Swig_var_NotifyBrokerOfCredit_NO_get, Swig_var_NotifyBrokerOfCredit_NO_set);
  SWIG_addvarlink(globals, "NotifyBrokerOfCredit_YES", Swig_var_NotifyBrokerOfCredit_YES_get, Swig_var_NotifyBrokerOfCredit_YES_set);
  SWIG_addvarlink(globals, "AllocHandlInst_MATCH", Swig_var_AllocHandlInst_MATCH_get, Swig_var_AllocHandlInst_MATCH_set);
  SWIG_addvarlink(globals, "AllocHandlInst_FORWARD", Swig_var_AllocHandlInst_FORWARD_get, Swig_var_AllocHandlInst_FORWARD_set);
  SWIG_addvarlink(globals, "AllocHandlInst_FORWARD_AND_MATCH", Swig_var_AllocHandlInst_FORWARD_AND_MATCH_get, Swig_var_AllocHandlInst_FORWARD_AND_MATCH_set);
  SWIG_addvarlink(globals, "AllocHandlInst_AUTO_CLAIM_GIVE_UP", Swig_var_AllocHandlInst_AUTO_CLAIM_GIVE_UP_get, Swig_var_AllocHandlInst_AUTO_CLAIM_GIVE_UP_set);
  SWIG_addvarlink(globals, "RoutingType_TARGET_FIRM", Swig_var_RoutingType_TARGET_FIRM_get, Swig_var_RoutingType_TARGET_FIRM_set);
  SWIG_addvarlink(globals, "RoutingType_TARGET_LIST", Swig_var_RoutingType_TARGET_LIST_get, Swig_var_RoutingType_TARGET_LIST_set);
  SWIG_addvarlink(globals, "RoutingType_BLOCK_FIRM", Swig_var_RoutingType_BLOCK_FIRM_get, Swig_var_RoutingType_BLOCK_FIRM_set);
  SWIG_addvarlink(globals, "RoutingType_BLOCK_LIST", Swig_var_RoutingType_BLOCK_LIST_get, Swig_var_RoutingType_BLOCK_LIST_set);
  SWIG_addvarlink(globals, "RoutingType_TARGET_PERSON", Swig_var_RoutingType_TARGET_PERSON_get, Swig_var_RoutingType_TARGET_PERSON_set);
  SWIG_addvarlink(globals, "RoutingType_BLOCK_PERSON", Swig_var_RoutingType_BLOCK_PERSON_get, Swig_var_RoutingType_BLOCK_PERSON_set);
  SWIG_addvarlink(globals, "Benchmark_CURVE", Swig_var_Benchmark_CURVE_get, Swig_var_Benchmark_CURVE_set);
  SWIG_addvarlink(globals, "Benchmark_FIVE_YR", Swig_var_Benchmark_FIVE_YR_get, Swig_var_Benchmark_FIVE_YR_set);
  SWIG_addvarlink(globals, "Benchmark_OLD5", Swig_var_Benchmark_OLD5_get, Swig_var_Benchmark_OLD5_set);
  SWIG_addvarlink(globals, "Benchmark_TEN_YR", Swig_var_Benchmark_TEN_YR_get, Swig_var_Benchmark_TEN_YR_set);
  SWIG_addvarlink(globals, "Benchmark_OLD10", Swig_var_Benchmark_OLD10_get, Swig_var_Benchmark_OLD10_set);
  SWIG_addvarlink(globals, "Benchmark_THIRTY_YR", Swig_var_Benchmark_THIRTY_YR_get, Swig_var_Benchmark_THIRTY_YR_set);
  SWIG_addvarlink(globals, "Benchmark_OLD30", Swig_var_Benchmark_OLD30_get, Swig_var_Benchmark_OLD30_set);
  SWIG_addvarlink(globals, "Benchmark_THREE_MOLIBOR", Swig_var_Benchmark_THREE_MOLIBOR_get, Swig_var_Benchmark_THREE_MOLIBOR_set);
  SWIG_addvarlink(globals, "Benchmark_SIX_MOLIBOR", Swig_var_Benchmark_SIX_MOLIBOR_get, Swig_var_Benchmark_SIX_MOLIBOR_set);
  SWIG_addvarlink(globals, "SubscriptionRequestType_SNAPSHOT", Swig_var_SubscriptionRequestType_SNAPSHOT_get, Swig_var_SubscriptionRequestType_SNAPSHOT_set);
  SWIG_addvarlink(globals, "SubscriptionRequestType_SNAPSHOT_AND_UPDATES", Swig_var_SubscriptionRequestType_SNAPSHOT_AND_UPDATES_get, Swig_var_SubscriptionRequestType_SNAPSHOT_AND_UPDATES_set);
  SWIG_addvarlink(globals, "SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT", Swig_var_SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_get, Swig_var_SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_set);
  SWIG_addvarlink(globals, "MDUpdateType_FULL_REFRESH", Swig_var_MDUpdateType_FULL_REFRESH_get, Swig_var_MDUpdateType_FULL_REFRESH_set);
  SWIG_addvarlink(globals, "MDUpdateType_INCREMENTAL_REFRESH", Swig_var_MDUpdateType_INCREMENTAL_REFRESH_get, Swig_var_MDUpdateType_INCREMENTAL_REFRESH_set);
  SWIG_addvarlink(globals, "AggregatedBook_NO", Swig_var_AggregatedBook_NO_get, Swig_var_AggregatedBook_NO_set);
  SWIG_addvarlink(globals, "AggregatedBook_YES", Swig_var_AggregatedBook_YES_get, Swig_var_AggregatedBook_YES_set);
  SWIG_addvarlink(globals, "MDEntryType_BID", Swig_var_MDEntryType_BID_get, Swig_var_MDEntryType_BID_set);
  SWIG_addvarlink(globals, "MDEntryType_OFFER", Swig_var_MDEntryType_OFFER_get, Swig_var_MDEntryType_OFFER_set);
  SWIG_addvarlink(globals, "MDEntryType_TRADE", Swig_var_MDEntryType_TRADE_get, Swig_var_MDEntryType_TRADE_set);
  SWIG_addvarlink(globals, "MDEntryType_INDEX_VALUE", Swig_var_MDEntryType_INDEX_VALUE_get, Swig_var_MDEntryType_INDEX_VALUE_set);
  SWIG_addvarlink(globals, "MDEntryType_OPENING_PRICE", Swig_var_MDEntryType_OPENING_PRICE_get, Swig_var_MDEntryType_OPENING_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_CLOSING_PRICE", Swig_var_MDEntryType_CLOSING_PRICE_get, Swig_var_MDEntryType_CLOSING_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_SETTLEMENT_PRICE", Swig_var_MDEntryType_SETTLEMENT_PRICE_get, Swig_var_MDEntryType_SETTLEMENT_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_TRADING_SESSION_HIGH_PRICE", Swig_var_MDEntryType_TRADING_SESSION_HIGH_PRICE_get, Swig_var_MDEntryType_TRADING_SESSION_HIGH_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_TRADING_SESSION_LOW_PRICE", Swig_var_MDEntryType_TRADING_SESSION_LOW_PRICE_get, Swig_var_MDEntryType_TRADING_SESSION_LOW_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_TRADING_SESSION_VWAP_PRICE", Swig_var_MDEntryType_TRADING_SESSION_VWAP_PRICE_get, Swig_var_MDEntryType_TRADING_SESSION_VWAP_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_IMBALANCE", Swig_var_MDEntryType_IMBALANCE_get, Swig_var_MDEntryType_IMBALANCE_set);
  SWIG_addvarlink(globals, "MDEntryType_TRADE_VOLUME", Swig_var_MDEntryType_TRADE_VOLUME_get, Swig_var_MDEntryType_TRADE_VOLUME_set);
  SWIG_addvarlink(globals, "MDEntryType_OPEN_INTEREST", Swig_var_MDEntryType_OPEN_INTEREST_get, Swig_var_MDEntryType_OPEN_INTEREST_set);
  SWIG_addvarlink(globals, "MDEntryType_COMPOSITE_UNDERLYING_PRICE", Swig_var_MDEntryType_COMPOSITE_UNDERLYING_PRICE_get, Swig_var_MDEntryType_COMPOSITE_UNDERLYING_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_SIMULATED_SELL_PRICE", Swig_var_MDEntryType_SIMULATED_SELL_PRICE_get, Swig_var_MDEntryType_SIMULATED_SELL_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_SIMULATED_BUY_PRICE", Swig_var_MDEntryType_SIMULATED_BUY_PRICE_get, Swig_var_MDEntryType_SIMULATED_BUY_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_MARGIN_RATE", Swig_var_MDEntryType_MARGIN_RATE_get, Swig_var_MDEntryType_MARGIN_RATE_set);
  SWIG_addvarlink(globals, "MDEntryType_MID_PRICE", Swig_var_MDEntryType_MID_PRICE_get, Swig_var_MDEntryType_MID_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_EMPTY_BOOK", Swig_var_MDEntryType_EMPTY_BOOK_get, Swig_var_MDEntryType_EMPTY_BOOK_set);
  SWIG_addvarlink(globals, "MDEntryType_SETTLE_HIGH_PRICE", Swig_var_MDEntryType_SETTLE_HIGH_PRICE_get, Swig_var_MDEntryType_SETTLE_HIGH_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_SETTLE_LOW_PRICE", Swig_var_MDEntryType_SETTLE_LOW_PRICE_get, Swig_var_MDEntryType_SETTLE_LOW_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_PRIOR_SETTLE_PRICE", Swig_var_MDEntryType_PRIOR_SETTLE_PRICE_get, Swig_var_MDEntryType_PRIOR_SETTLE_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_SESSION_HIGH_BID", Swig_var_MDEntryType_SESSION_HIGH_BID_get, Swig_var_MDEntryType_SESSION_HIGH_BID_set);
  SWIG_addvarlink(globals, "MDEntryType_SESSION_LOW_OFFER", Swig_var_MDEntryType_SESSION_LOW_OFFER_get, Swig_var_MDEntryType_SESSION_LOW_OFFER_set);
  SWIG_addvarlink(globals, "MDEntryType_EARLY_PRICES", Swig_var_MDEntryType_EARLY_PRICES_get, Swig_var_MDEntryType_EARLY_PRICES_set);
  SWIG_addvarlink(globals, "MDEntryType_AUCTION_CLEARING_PRICE", Swig_var_MDEntryType_AUCTION_CLEARING_PRICE_get, Swig_var_MDEntryType_AUCTION_CLEARING_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_SWAP_VALUE_FACTOR", Swig_var_MDEntryType_SWAP_VALUE_FACTOR_get, Swig_var_MDEntryType_SWAP_VALUE_FACTOR_set);
  SWIG_addvarlink(globals, "MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS", Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get, Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_set);
  SWIG_addvarlink(globals, "MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS", Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get, Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_set);
  SWIG_addvarlink(globals, "MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS", Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get, Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_set);
  SWIG_addvarlink(globals, "MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS", Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get, Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_set);
  SWIG_addvarlink(globals, "MDEntryType_VWAP", Swig_var_MDEntryType_VWAP_get, Swig_var_MDEntryType_VWAP_set);
  SWIG_addvarlink(globals, "MDEntryType_FIXING_PRICE", Swig_var_MDEntryType_FIXING_PRICE_get, Swig_var_MDEntryType_FIXING_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_CASH_RATE", Swig_var_MDEntryType_CASH_RATE_get, Swig_var_MDEntryType_CASH_RATE_set);
  SWIG_addvarlink(globals, "MDEntryType_RECOVERY_RATE", Swig_var_MDEntryType_RECOVERY_RATE_get, Swig_var_MDEntryType_RECOVERY_RATE_set);
  SWIG_addvarlink(globals, "MDEntryType_RECOVERY_RATE_FOR_LONG", Swig_var_MDEntryType_RECOVERY_RATE_FOR_LONG_get, Swig_var_MDEntryType_RECOVERY_RATE_FOR_LONG_set);
  SWIG_addvarlink(globals, "MDEntryType_RECOVERY_RATE_FOR_SHORT", Swig_var_MDEntryType_RECOVERY_RATE_FOR_SHORT_get, Swig_var_MDEntryType_RECOVERY_RATE_FOR_SHORT_set);
  SWIG_addvarlink(globals, "MDEntryType_MARKET_BID", Swig_var_MDEntryType_MARKET_BID_get, Swig_var_MDEntryType_MARKET_BID_set);
  SWIG_addvarlink(globals, "MDEntryType_MARKET_OFFER", Swig_var_MDEntryType_MARKET_OFFER_get, Swig_var_MDEntryType_MARKET_OFFER_set);
  SWIG_addvarlink(globals, "MDEntryType_SHORT_SALE_MIN_PRICE", Swig_var_MDEntryType_SHORT_SALE_MIN_PRICE_get, Swig_var_MDEntryType_SHORT_SALE_MIN_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_PREVIOUS_CLOSING_PRICE", Swig_var_MDEntryType_PREVIOUS_CLOSING_PRICE_get, Swig_var_MDEntryType_PREVIOUS_CLOSING_PRICE_set);
  SWIG_addvarlink(globals, "MDEntryType_THRESHOLD_LIMIT_PRICE_BANDING", Swig_var_MDEntryType_THRESHOLD_LIMIT_PRICE_BANDING_get, Swig_var_MDEntryType_THRESHOLD_LIMIT_PRICE_BANDING_set);
  SWIG_addvarlink(globals, "MDEntryType_DAILY_FINANCING_VALUE", Swig_var_MDEntryType_DAILY_FINANCING_VALUE_get, Swig_var_MDEntryType_DAILY_FINANCING_VALUE_set);
  SWIG_addvarlink(globals, "MDEntryType_ACCRUED_FINANCING_VALUE", Swig_var_MDEntryType_ACCRUED_FINANCING_VALUE_get, Swig_var_MDEntryType_ACCRUED_FINANCING_VALUE_set);
  SWIG_addvarlink(globals, "MDEntryType_TWAP", Swig_var_MDEntryType_TWAP_get, Swig_var_MDEntryType_TWAP_set);
  SWIG_addvarlink(globals, "TickDirection_PLUS_TICK", Swig_var_TickDirection_PLUS_TICK_get, Swig_var_TickDirection_PLUS_TICK_set);
  SWIG_addvarlink(globals, "TickDirection_ZERO_PLUS_TICK", Swig_var_TickDirection_ZERO_PLUS_TICK_get, Swig_var_TickDirection_ZERO_PLUS_TICK_set);
  SWIG_addvarlink(globals, "TickDirection_MINUS_TICK", Swig_var_TickDirection_MINUS_TICK_get, Swig_var_TickDirection_MINUS_TICK_set);
  SWIG_addvarlink(globals, "TickDirection_ZERO_MINUS_TICK", Swig_var_TickDirection_ZERO_MINUS_TICK_get, Swig_var_TickDirection_ZERO_MINUS_TICK_set);
  SWIG_addvarlink(globals, "QuoteCondition_OPEN", Swig_var_QuoteCondition_OPEN_get, Swig_var_QuoteCondition_OPEN_set);
  SWIG_addvarlink(globals, "QuoteCondition_CLOSED", Swig_var_QuoteCondition_CLOSED_get, Swig_var_QuoteCondition_CLOSED_set);
  SWIG_addvarlink(globals, "QuoteCondition_EXCHANGE_BEST", Swig_var_QuoteCondition_EXCHANGE_BEST_get, Swig_var_QuoteCondition_EXCHANGE_BEST_set);
  SWIG_addvarlink(globals, "QuoteCondition_CONSOLIDATED_BEST", Swig_var_QuoteCondition_CONSOLIDATED_BEST_get, Swig_var_QuoteCondition_CONSOLIDATED_BEST_set);
  SWIG_addvarlink(globals, "QuoteCondition_LOCKED", Swig_var_QuoteCondition_LOCKED_get, Swig_var_QuoteCondition_LOCKED_set);
  SWIG_addvarlink(globals, "QuoteCondition_CROSSED", Swig_var_QuoteCondition_CROSSED_get, Swig_var_QuoteCondition_CROSSED_set);
  SWIG_addvarlink(globals, "QuoteCondition_DEPTH", Swig_var_QuoteCondition_DEPTH_get, Swig_var_QuoteCondition_DEPTH_set);
  SWIG_addvarlink(globals, "QuoteCondition_FAST_TRADING", Swig_var_QuoteCondition_FAST_TRADING_get, Swig_var_QuoteCondition_FAST_TRADING_set);
  SWIG_addvarlink(globals, "QuoteCondition_NON_FIRM", Swig_var_QuoteCondition_NON_FIRM_get, Swig_var_QuoteCondition_NON_FIRM_set);
  SWIG_addvarlink(globals, "QuoteCondition_MANUAL", Swig_var_QuoteCondition_MANUAL_get, Swig_var_QuoteCondition_MANUAL_set);
  SWIG_addvarlink(globals, "QuoteCondition_OUTRIGHT_PRICE", Swig_var_QuoteCondition_OUTRIGHT_PRICE_get, Swig_var_QuoteCondition_OUTRIGHT_PRICE_set);
  SWIG_addvarlink(globals, "QuoteCondition_IMPLIED_PRICE", Swig_var_QuoteCondition_IMPLIED_PRICE_get, Swig_var_QuoteCondition_IMPLIED_PRICE_set);
  SWIG_addvarlink(globals, "QuoteCondition_DEPTH_ON_OFFER", Swig_var_QuoteCondition_DEPTH_ON_OFFER_get, Swig_var_QuoteCondition_DEPTH_ON_OFFER_set);
  SWIG_addvarlink(globals, "QuoteCondition_DEPTH_ON_BID", Swig_var_QuoteCondition_DEPTH_ON_BID_get, Swig_var_QuoteCondition_DEPTH_ON_BID_set);
  SWIG_addvarlink(globals, "QuoteCondition_CLOSING", Swig_var_QuoteCondition_CLOSING_get, Swig_var_QuoteCondition_CLOSING_set);
  SWIG_addvarlink(globals, "QuoteCondition_NEWS_DISSEMINATION", Swig_var_QuoteCondition_NEWS_DISSEMINATION_get, Swig_var_QuoteCondition_NEWS_DISSEMINATION_set);
  SWIG_addvarlink(globals, "QuoteCondition_TRADING_RANGE", Swig_var_QuoteCondition_TRADING_RANGE_get, Swig_var_QuoteCondition_TRADING_RANGE_set);
  SWIG_addvarlink(globals, "QuoteCondition_ORDER_INFLUX", Swig_var_QuoteCondition_ORDER_INFLUX_get, Swig_var_QuoteCondition_ORDER_INFLUX_set);
  SWIG_addvarlink(globals, "QuoteCondition_DUE_TO_RELATED", Swig_var_QuoteCondition_DUE_TO_RELATED_get, Swig_var_QuoteCondition_DUE_TO_RELATED_set);
  SWIG_addvarlink(globals, "QuoteCondition_NEWS_PENDING", Swig_var_QuoteCondition_NEWS_PENDING_get, Swig_var_QuoteCondition_NEWS_PENDING_set);
  SWIG_addvarlink(globals, "QuoteCondition_ADDITIONAL_INFO", Swig_var_QuoteCondition_ADDITIONAL_INFO_get, Swig_var_QuoteCondition_ADDITIONAL_INFO_set);
  SWIG_addvarlink(globals, "QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED", Swig_var_QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED_get, Swig_var_QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED_set);
  SWIG_addvarlink(globals, "QuoteCondition_RESUME", Swig_var_QuoteCondition_RESUME_get, Swig_var_QuoteCondition_RESUME_set);
  SWIG_addvarlink(globals, "QuoteCondition_VIEW_OF_COMMON", Swig_var_QuoteCondition_VIEW_OF_COMMON_get, Swig_var_QuoteCondition_VIEW_OF_COMMON_set);
  SWIG_addvarlink(globals, "QuoteCondition_VOLUME_ALERT", Swig_var_QuoteCondition_VOLUME_ALERT_get, Swig_var_QuoteCondition_VOLUME_ALERT_set);
  SWIG_addvarlink(globals, "QuoteCondition_ORDER_IMBALANCE", Swig_var_QuoteCondition_ORDER_IMBALANCE_get, Swig_var_QuoteCondition_ORDER_IMBALANCE_set);
  SWIG_addvarlink(globals, "QuoteCondition_EQUIPMENT_CHANGEOVER", Swig_var_QuoteCondition_EQUIPMENT_CHANGEOVER_get, Swig_var_QuoteCondition_EQUIPMENT_CHANGEOVER_set);
  SWIG_addvarlink(globals, "QuoteCondition_NO_OPEN", Swig_var_QuoteCondition_NO_OPEN_get, Swig_var_QuoteCondition_NO_OPEN_set);
  SWIG_addvarlink(globals, "QuoteCondition_REGULAR_ETH", Swig_var_QuoteCondition_REGULAR_ETH_get, Swig_var_QuoteCondition_REGULAR_ETH_set);
  SWIG_addvarlink(globals, "QuoteCondition_AUTOMATIC_EXECUTION", Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_get, Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_set);
  SWIG_addvarlink(globals, "QuoteCondition_AUTOMATIC_EXECUTION_ETH", Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_ETH_get, Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_ETH_set);
  SWIG_addvarlink(globals, "QuoteCondition_FAST_MARKET_ETH", Swig_var_QuoteCondition_FAST_MARKET_ETH_get, Swig_var_QuoteCondition_FAST_MARKET_ETH_set);
  SWIG_addvarlink(globals, "QuoteCondition_INACTIVE_ETH", Swig_var_QuoteCondition_INACTIVE_ETH_get, Swig_var_QuoteCondition_INACTIVE_ETH_set);
  SWIG_addvarlink(globals, "QuoteCondition_ROTATION", Swig_var_QuoteCondition_ROTATION_get, Swig_var_QuoteCondition_ROTATION_set);
  SWIG_addvarlink(globals, "QuoteCondition_ROTATION_ETH", Swig_var_QuoteCondition_ROTATION_ETH_get, Swig_var_QuoteCondition_ROTATION_ETH_set);
  SWIG_addvarlink(globals, "QuoteCondition_HALT", Swig_var_QuoteCondition_HALT_get, Swig_var_QuoteCondition_HALT_set);
  SWIG_addvarlink(globals, "QuoteCondition_HALT_ETH", Swig_var_QuoteCondition_HALT_ETH_get, Swig_var_QuoteCondition_HALT_ETH_set);
  SWIG_addvarlink(globals, "QuoteCondition_DUE_TO_NEWS_DISSEMINATION", Swig_var_QuoteCondition_DUE_TO_NEWS_DISSEMINATION_get, Swig_var_QuoteCondition_DUE_TO_NEWS_DISSEMINATION_set);
  SWIG_addvarlink(globals, "QuoteCondition_DUE_TO_NEWS_PENDING", Swig_var_QuoteCondition_DUE_TO_NEWS_PENDING_get, Swig_var_QuoteCondition_DUE_TO_NEWS_PENDING_set);
  SWIG_addvarlink(globals, "QuoteCondition_TRADING_RESUME", Swig_var_QuoteCondition_TRADING_RESUME_get, Swig_var_QuoteCondition_TRADING_RESUME_set);
  SWIG_addvarlink(globals, "QuoteCondition_OUT_OF_SEQUENCE", Swig_var_QuoteCondition_OUT_OF_SEQUENCE_get, Swig_var_QuoteCondition_OUT_OF_SEQUENCE_set);
  SWIG_addvarlink(globals, "QuoteCondition_BID_SPECIALIST", Swig_var_QuoteCondition_BID_SPECIALIST_get, Swig_var_QuoteCondition_BID_SPECIALIST_set);
  SWIG_addvarlink(globals, "QuoteCondition_OFFER_SPECIALIST", Swig_var_QuoteCondition_OFFER_SPECIALIST_get, Swig_var_QuoteCondition_OFFER_SPECIALIST_set);
  SWIG_addvarlink(globals, "QuoteCondition_BID_OFFER_SPECIALIST", Swig_var_QuoteCondition_BID_OFFER_SPECIALIST_get, Swig_var_QuoteCondition_BID_OFFER_SPECIALIST_set);
  SWIG_addvarlink(globals, "QuoteCondition_END_OF_DAY_SAM", Swig_var_QuoteCondition_END_OF_DAY_SAM_get, Swig_var_QuoteCondition_END_OF_DAY_SAM_set);
  SWIG_addvarlink(globals, "QuoteCondition_FORBIDDEN_SAM", Swig_var_QuoteCondition_FORBIDDEN_SAM_get, Swig_var_QuoteCondition_FORBIDDEN_SAM_set);
  SWIG_addvarlink(globals, "QuoteCondition_FROZEN_SAM", Swig_var_QuoteCondition_FROZEN_SAM_get, Swig_var_QuoteCondition_FROZEN_SAM_set);
  SWIG_addvarlink(globals, "QuoteCondition_PRE_OPENING_SAM", Swig_var_QuoteCondition_PRE_OPENING_SAM_get, Swig_var_QuoteCondition_PRE_OPENING_SAM_set);
  SWIG_addvarlink(globals, "QuoteCondition_OPENING_SAM", Swig_var_QuoteCondition_OPENING_SAM_get, Swig_var_QuoteCondition_OPENING_SAM_set);
  SWIG_addvarlink(globals, "QuoteCondition_OPEN_SAM", Swig_var_QuoteCondition_OPEN_SAM_get, Swig_var_QuoteCondition_OPEN_SAM_set);
  SWIG_addvarlink(globals, "QuoteCondition_SURVEILLANCE_SAM", Swig_var_QuoteCondition_SURVEILLANCE_SAM_get, Swig_var_QuoteCondition_SURVEILLANCE_SAM_set);
  SWIG_addvarlink(globals, "QuoteCondition_SUSPENDED_SAM", Swig_var_QuoteCondition_SUSPENDED_SAM_get, Swig_var_QuoteCondition_SUSPENDED_SAM_set);
  SWIG_addvarlink(globals, "QuoteCondition_RESERVED_SAM", Swig_var_QuoteCondition_RESERVED_SAM_get, Swig_var_QuoteCondition_RESERVED_SAM_set);
  SWIG_addvarlink(globals, "QuoteCondition_NO_ACTIVE_SAM", Swig_var_QuoteCondition_NO_ACTIVE_SAM_get, Swig_var_QuoteCondition_NO_ACTIVE_SAM_set);
  SWIG_addvarlink(globals, "QuoteCondition_RESTRICTED", Swig_var_QuoteCondition_RESTRICTED_get, Swig_var_QuoteCondition_RESTRICTED_set);
  SWIG_addvarlink(globals, "QuoteCondition_REST_OF_BOOK_VWAP", Swig_var_QuoteCondition_REST_OF_BOOK_VWAP_get, Swig_var_QuoteCondition_REST_OF_BOOK_VWAP_set);
  SWIG_addvarlink(globals, "QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS", Swig_var_QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS_get, Swig_var_QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS_set);
  SWIG_addvarlink(globals, "QuoteCondition_MEDIAN_PRICE", Swig_var_QuoteCondition_MEDIAN_PRICE_get, Swig_var_QuoteCondition_MEDIAN_PRICE_set);
  SWIG_addvarlink(globals, "QuoteCondition_FULL_CURVE", Swig_var_QuoteCondition_FULL_CURVE_get, Swig_var_QuoteCondition_FULL_CURVE_set);
  SWIG_addvarlink(globals, "QuoteCondition_FLAT_CURVE", Swig_var_QuoteCondition_FLAT_CURVE_get, Swig_var_QuoteCondition_FLAT_CURVE_set);
  SWIG_addvarlink(globals, "TradeCondition_CASH", Swig_var_TradeCondition_CASH_get, Swig_var_TradeCondition_CASH_set);
  SWIG_addvarlink(globals, "TradeCondition_AVERAGE_PRICE_TRADE", Swig_var_TradeCondition_AVERAGE_PRICE_TRADE_get, Swig_var_TradeCondition_AVERAGE_PRICE_TRADE_set);
  SWIG_addvarlink(globals, "TradeCondition_CASH_TRADE", Swig_var_TradeCondition_CASH_TRADE_get, Swig_var_TradeCondition_CASH_TRADE_set);
  SWIG_addvarlink(globals, "TradeCondition_NEXT_DAY", Swig_var_TradeCondition_NEXT_DAY_get, Swig_var_TradeCondition_NEXT_DAY_set);
  SWIG_addvarlink(globals, "TradeCondition_OPENING", Swig_var_TradeCondition_OPENING_get, Swig_var_TradeCondition_OPENING_set);
  SWIG_addvarlink(globals, "TradeCondition_INTRADAY_TRADE_DETAIL", Swig_var_TradeCondition_INTRADAY_TRADE_DETAIL_get, Swig_var_TradeCondition_INTRADAY_TRADE_DETAIL_set);
  SWIG_addvarlink(globals, "TradeCondition_RULE127_TRADE", Swig_var_TradeCondition_RULE127_TRADE_get, Swig_var_TradeCondition_RULE127_TRADE_set);
  SWIG_addvarlink(globals, "TradeCondition_RULE155_TRADE", Swig_var_TradeCondition_RULE155_TRADE_get, Swig_var_TradeCondition_RULE155_TRADE_set);
  SWIG_addvarlink(globals, "TradeCondition_SOLD_LAST", Swig_var_TradeCondition_SOLD_LAST_get, Swig_var_TradeCondition_SOLD_LAST_set);
  SWIG_addvarlink(globals, "TradeCondition_NEXT_DAY_TRADE", Swig_var_TradeCondition_NEXT_DAY_TRADE_get, Swig_var_TradeCondition_NEXT_DAY_TRADE_set);
  SWIG_addvarlink(globals, "TradeCondition_OPENED", Swig_var_TradeCondition_OPENED_get, Swig_var_TradeCondition_OPENED_set);
  SWIG_addvarlink(globals, "TradeCondition_SELLER", Swig_var_TradeCondition_SELLER_get, Swig_var_TradeCondition_SELLER_set);
  SWIG_addvarlink(globals, "TradeCondition_SOLD", Swig_var_TradeCondition_SOLD_get, Swig_var_TradeCondition_SOLD_set);
  SWIG_addvarlink(globals, "TradeCondition_STOPPED_STOCK", Swig_var_TradeCondition_STOPPED_STOCK_get, Swig_var_TradeCondition_STOPPED_STOCK_set);
  SWIG_addvarlink(globals, "TradeCondition_IMBALANCE_MORE_BUYERS", Swig_var_TradeCondition_IMBALANCE_MORE_BUYERS_get, Swig_var_TradeCondition_IMBALANCE_MORE_BUYERS_set);
  SWIG_addvarlink(globals, "TradeCondition_IMBALANCE_MORE_SELLERS", Swig_var_TradeCondition_IMBALANCE_MORE_SELLERS_get, Swig_var_TradeCondition_IMBALANCE_MORE_SELLERS_set);
  SWIG_addvarlink(globals, "TradeCondition_OPENING_PRICE", Swig_var_TradeCondition_OPENING_PRICE_get, Swig_var_TradeCondition_OPENING_PRICE_set);
  SWIG_addvarlink(globals, "TradeCondition_BARGAIN_CONDITION", Swig_var_TradeCondition_BARGAIN_CONDITION_get, Swig_var_TradeCondition_BARGAIN_CONDITION_set);
  SWIG_addvarlink(globals, "TradeCondition_CONVERTED_PRICE_INDICATOR", Swig_var_TradeCondition_CONVERTED_PRICE_INDICATOR_get, Swig_var_TradeCondition_CONVERTED_PRICE_INDICATOR_set);
  SWIG_addvarlink(globals, "TradeCondition_EXCHANGE_LAST", Swig_var_TradeCondition_EXCHANGE_LAST_get, Swig_var_TradeCondition_EXCHANGE_LAST_set);
  SWIG_addvarlink(globals, "TradeCondition_FINAL_PRICE_OF_SESSION", Swig_var_TradeCondition_FINAL_PRICE_OF_SESSION_get, Swig_var_TradeCondition_FINAL_PRICE_OF_SESSION_set);
  SWIG_addvarlink(globals, "TradeCondition_EX_PIT", Swig_var_TradeCondition_EX_PIT_get, Swig_var_TradeCondition_EX_PIT_set);
  SWIG_addvarlink(globals, "TradeCondition_CROSSED", Swig_var_TradeCondition_CROSSED_get, Swig_var_TradeCondition_CROSSED_set);
  SWIG_addvarlink(globals, "TradeCondition_TRADES_RESULTING_FROM_MANUAL", Swig_var_TradeCondition_TRADES_RESULTING_FROM_MANUAL_get, Swig_var_TradeCondition_TRADES_RESULTING_FROM_MANUAL_set);
  SWIG_addvarlink(globals, "TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP", Swig_var_TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP_get, Swig_var_TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP_set);
  SWIG_addvarlink(globals, "TradeCondition_VOLUME_ONLY", Swig_var_TradeCondition_VOLUME_ONLY_get, Swig_var_TradeCondition_VOLUME_ONLY_set);
  SWIG_addvarlink(globals, "TradeCondition_DIRECT_PLUS", Swig_var_TradeCondition_DIRECT_PLUS_get, Swig_var_TradeCondition_DIRECT_PLUS_set);
  SWIG_addvarlink(globals, "TradeCondition_ACQUISITION", Swig_var_TradeCondition_ACQUISITION_get, Swig_var_TradeCondition_ACQUISITION_set);
  SWIG_addvarlink(globals, "TradeCondition_BUNCHED", Swig_var_TradeCondition_BUNCHED_get, Swig_var_TradeCondition_BUNCHED_set);
  SWIG_addvarlink(globals, "TradeCondition_DISTRIBUTION", Swig_var_TradeCondition_DISTRIBUTION_get, Swig_var_TradeCondition_DISTRIBUTION_set);
  SWIG_addvarlink(globals, "TradeCondition_BUNCHED_SALE", Swig_var_TradeCondition_BUNCHED_SALE_get, Swig_var_TradeCondition_BUNCHED_SALE_set);
  SWIG_addvarlink(globals, "TradeCondition_SPLIT_TRADE", Swig_var_TradeCondition_SPLIT_TRADE_get, Swig_var_TradeCondition_SPLIT_TRADE_set);
  SWIG_addvarlink(globals, "TradeCondition_CANCEL_STOPPED", Swig_var_TradeCondition_CANCEL_STOPPED_get, Swig_var_TradeCondition_CANCEL_STOPPED_set);
  SWIG_addvarlink(globals, "TradeCondition_CANCEL_ETH", Swig_var_TradeCondition_CANCEL_ETH_get, Swig_var_TradeCondition_CANCEL_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_CANCEL_STOPPED_ETH", Swig_var_TradeCondition_CANCEL_STOPPED_ETH_get, Swig_var_TradeCondition_CANCEL_STOPPED_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_OUT_OF_SEQUENCE_ETH", Swig_var_TradeCondition_OUT_OF_SEQUENCE_ETH_get, Swig_var_TradeCondition_OUT_OF_SEQUENCE_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_CANCEL_LAST_ETH", Swig_var_TradeCondition_CANCEL_LAST_ETH_get, Swig_var_TradeCondition_CANCEL_LAST_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_SOLD_LAST_SALE_ETH", Swig_var_TradeCondition_SOLD_LAST_SALE_ETH_get, Swig_var_TradeCondition_SOLD_LAST_SALE_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_CANCEL_LAST", Swig_var_TradeCondition_CANCEL_LAST_get, Swig_var_TradeCondition_CANCEL_LAST_set);
  SWIG_addvarlink(globals, "TradeCondition_SOLD_LAST_SALE", Swig_var_TradeCondition_SOLD_LAST_SALE_get, Swig_var_TradeCondition_SOLD_LAST_SALE_set);
  SWIG_addvarlink(globals, "TradeCondition_CANCEL_OPEN", Swig_var_TradeCondition_CANCEL_OPEN_get, Swig_var_TradeCondition_CANCEL_OPEN_set);
  SWIG_addvarlink(globals, "TradeCondition_CANCEL_OPEN_ETH", Swig_var_TradeCondition_CANCEL_OPEN_ETH_get, Swig_var_TradeCondition_CANCEL_OPEN_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_OPENED_SALE_ETH", Swig_var_TradeCondition_OPENED_SALE_ETH_get, Swig_var_TradeCondition_OPENED_SALE_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_CANCEL_ONLY", Swig_var_TradeCondition_CANCEL_ONLY_get, Swig_var_TradeCondition_CANCEL_ONLY_set);
  SWIG_addvarlink(globals, "TradeCondition_CANCEL_ONLY_ETH", Swig_var_TradeCondition_CANCEL_ONLY_ETH_get, Swig_var_TradeCondition_CANCEL_ONLY_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_LATE_OPEN_ETH", Swig_var_TradeCondition_LATE_OPEN_ETH_get, Swig_var_TradeCondition_LATE_OPEN_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_AUTO_EXECUTION_ETH", Swig_var_TradeCondition_AUTO_EXECUTION_ETH_get, Swig_var_TradeCondition_AUTO_EXECUTION_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_REOPEN", Swig_var_TradeCondition_REOPEN_get, Swig_var_TradeCondition_REOPEN_set);
  SWIG_addvarlink(globals, "TradeCondition_REOPEN_ETH", Swig_var_TradeCondition_REOPEN_ETH_get, Swig_var_TradeCondition_REOPEN_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_ADJUSTED", Swig_var_TradeCondition_ADJUSTED_get, Swig_var_TradeCondition_ADJUSTED_set);
  SWIG_addvarlink(globals, "TradeCondition_ADJUSTED_ETH", Swig_var_TradeCondition_ADJUSTED_ETH_get, Swig_var_TradeCondition_ADJUSTED_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_SPREAD", Swig_var_TradeCondition_SPREAD_get, Swig_var_TradeCondition_SPREAD_set);
  SWIG_addvarlink(globals, "TradeCondition_SPREAD_ETH", Swig_var_TradeCondition_SPREAD_ETH_get, Swig_var_TradeCondition_SPREAD_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_STRADDLE", Swig_var_TradeCondition_STRADDLE_get, Swig_var_TradeCondition_STRADDLE_set);
  SWIG_addvarlink(globals, "TradeCondition_STRADDLE_ETH", Swig_var_TradeCondition_STRADDLE_ETH_get, Swig_var_TradeCondition_STRADDLE_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_STOPPED", Swig_var_TradeCondition_STOPPED_get, Swig_var_TradeCondition_STOPPED_set);
  SWIG_addvarlink(globals, "TradeCondition_STOPPED_ETH", Swig_var_TradeCondition_STOPPED_ETH_get, Swig_var_TradeCondition_STOPPED_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_REGULAR_ETH", Swig_var_TradeCondition_REGULAR_ETH_get, Swig_var_TradeCondition_REGULAR_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_COMBO", Swig_var_TradeCondition_COMBO_get, Swig_var_TradeCondition_COMBO_set);
  SWIG_addvarlink(globals, "TradeCondition_COMBO_ETH", Swig_var_TradeCondition_COMBO_ETH_get, Swig_var_TradeCondition_COMBO_ETH_set);
  SWIG_addvarlink(globals, "TradeCondition_OFFICIAL_CLOSING_PRICE", Swig_var_TradeCondition_OFFICIAL_CLOSING_PRICE_get, Swig_var_TradeCondition_OFFICIAL_CLOSING_PRICE_set);
  SWIG_addvarlink(globals, "TradeCondition_PRIOR_REFERENCE_PRICE", Swig_var_TradeCondition_PRIOR_REFERENCE_PRICE_get, Swig_var_TradeCondition_PRIOR_REFERENCE_PRICE_set);
  SWIG_addvarlink(globals, "TradeCondition_CANCEL", Swig_var_TradeCondition_CANCEL_get, Swig_var_TradeCondition_CANCEL_set);
  SWIG_addvarlink(globals, "TradeCondition_STOPPED_SOLD_LAST", Swig_var_TradeCondition_STOPPED_SOLD_LAST_get, Swig_var_TradeCondition_STOPPED_SOLD_LAST_set);
  SWIG_addvarlink(globals, "TradeCondition_STOPPED_OUT_OF_SEQUENCE", Swig_var_TradeCondition_STOPPED_OUT_OF_SEQUENCE_get, Swig_var_TradeCondition_STOPPED_OUT_OF_SEQUENCE_set);
  SWIG_addvarlink(globals, "TradeCondition_OFFICAL_CLOSING_PRICE", Swig_var_TradeCondition_OFFICAL_CLOSING_PRICE_get, Swig_var_TradeCondition_OFFICAL_CLOSING_PRICE_set);
  SWIG_addvarlink(globals, "TradeCondition_CROSSED_OLD", Swig_var_TradeCondition_CROSSED_OLD_get, Swig_var_TradeCondition_CROSSED_OLD_set);
  SWIG_addvarlink(globals, "TradeCondition_FAST_MARKET", Swig_var_TradeCondition_FAST_MARKET_get, Swig_var_TradeCondition_FAST_MARKET_set);
  SWIG_addvarlink(globals, "TradeCondition_AUTOMATIC_EXECUTION", Swig_var_TradeCondition_AUTOMATIC_EXECUTION_get, Swig_var_TradeCondition_AUTOMATIC_EXECUTION_set);
  SWIG_addvarlink(globals, "TradeCondition_FORM_T", Swig_var_TradeCondition_FORM_T_get, Swig_var_TradeCondition_FORM_T_set);
  SWIG_addvarlink(globals, "TradeCondition_BASKET_INDEX", Swig_var_TradeCondition_BASKET_INDEX_get, Swig_var_TradeCondition_BASKET_INDEX_set);
  SWIG_addvarlink(globals, "TradeCondition_BURST_BASKET", Swig_var_TradeCondition_BURST_BASKET_get, Swig_var_TradeCondition_BURST_BASKET_set);
  SWIG_addvarlink(globals, "TradeCondition_OUTSIDE_SPREAD", Swig_var_TradeCondition_OUTSIDE_SPREAD_get, Swig_var_TradeCondition_OUTSIDE_SPREAD_set);
  SWIG_addvarlink(globals, "TradeCondition_IMPLIED_TRADE", Swig_var_TradeCondition_IMPLIED_TRADE_get, Swig_var_TradeCondition_IMPLIED_TRADE_set);
  SWIG_addvarlink(globals, "TradeCondition_MARKETPLACE_ENTERED_TRADE", Swig_var_TradeCondition_MARKETPLACE_ENTERED_TRADE_get, Swig_var_TradeCondition_MARKETPLACE_ENTERED_TRADE_set);
  SWIG_addvarlink(globals, "TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE", Swig_var_TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE_get, Swig_var_TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE_set);
  SWIG_addvarlink(globals, "TradeCondition_MULTILEG_TO_MULTILEG_TRADE", Swig_var_TradeCondition_MULTILEG_TO_MULTILEG_TRADE_get, Swig_var_TradeCondition_MULTILEG_TO_MULTILEG_TRADE_set);
  SWIG_addvarlink(globals, "TradeCondition_OFFICIAL_CLOSING_PRICE_DUP", Swig_var_TradeCondition_OFFICIAL_CLOSING_PRICE_DUP_get, Swig_var_TradeCondition_OFFICIAL_CLOSING_PRICE_DUP_set);
  SWIG_addvarlink(globals, "TradeCondition_TRADE_THROUGH_EXEMPT", Swig_var_TradeCondition_TRADE_THROUGH_EXEMPT_get, Swig_var_TradeCondition_TRADE_THROUGH_EXEMPT_set);
  SWIG_addvarlink(globals, "TradeCondition_QUOTE_SPREAD", Swig_var_TradeCondition_QUOTE_SPREAD_get, Swig_var_TradeCondition_QUOTE_SPREAD_set);
  SWIG_addvarlink(globals, "TradeCondition_LAST_AUCTION_PRICE", Swig_var_TradeCondition_LAST_AUCTION_PRICE_get, Swig_var_TradeCondition_LAST_AUCTION_PRICE_set);
  SWIG_addvarlink(globals, "TradeCondition_HIGH_PRICE", Swig_var_TradeCondition_HIGH_PRICE_get, Swig_var_TradeCondition_HIGH_PRICE_set);
  SWIG_addvarlink(globals, "TradeCondition_LOW_PRICE", Swig_var_TradeCondition_LOW_PRICE_get, Swig_var_TradeCondition_LOW_PRICE_set);
  SWIG_addvarlink(globals, "TradeCondition_SYSTEMATIC_INTERNALISER", Swig_var_TradeCondition_SYSTEMATIC_INTERNALISER_get, Swig_var_TradeCondition_SYSTEMATIC_INTERNALISER_set);
  SWIG_addvarlink(globals, "TradeCondition_AWAY_MARKET", Swig_var_TradeCondition_AWAY_MARKET_get, Swig_var_TradeCondition_AWAY_MARKET_set);
  SWIG_addvarlink(globals, "TradeCondition_MIDPOINT_PRICE", Swig_var_TradeCondition_MIDPOINT_PRICE_get, Swig_var_TradeCondition_MIDPOINT_PRICE_set);
  SWIG_addvarlink(globals, "TradeCondition_TRADED_BEFORE_ISSUE_DATE", Swig_var_TradeCondition_TRADED_BEFORE_ISSUE_DATE_get, Swig_var_TradeCondition_TRADED_BEFORE_ISSUE_DATE_set);
  SWIG_addvarlink(globals, "TradeCondition_PREVIOUS_CLOSING_PRICE", Swig_var_TradeCondition_PREVIOUS_CLOSING_PRICE_get, Swig_var_TradeCondition_PREVIOUS_CLOSING_PRICE_set);
  SWIG_addvarlink(globals, "TradeCondition_NATIONAL_BEST_BID_OFFER", Swig_var_TradeCondition_NATIONAL_BEST_BID_OFFER_get, Swig_var_TradeCondition_NATIONAL_BEST_BID_OFFER_set);
  SWIG_addvarlink(globals, "TradeCondition_MULTI_ASSET_CLASS_MULTILEG_TRADE", Swig_var_TradeCondition_MULTI_ASSET_CLASS_MULTILEG_TRADE_get, Swig_var_TradeCondition_MULTI_ASSET_CLASS_MULTILEG_TRADE_set);
  SWIG_addvarlink(globals, "TradeCondition_SHORT_SALE_MIN_PRICE", Swig_var_TradeCondition_SHORT_SALE_MIN_PRICE_get, Swig_var_TradeCondition_SHORT_SALE_MIN_PRICE_set);
  SWIG_addvarlink(globals, "TradeCondition_BENCHMARK", Swig_var_TradeCondition_BENCHMARK_get, Swig_var_TradeCondition_BENCHMARK_set);
  SWIG_addvarlink(globals, "MDUpdateAction_NEW", Swig_var_MDUpdateAction_NEW_get, Swig_var_MDUpdateAction_NEW_set);
  SWIG_addvarlink(globals, "MDUpdateAction_CHANGE", Swig_var_MDUpdateAction_CHANGE_get, Swig_var_MDUpdateAction_CHANGE_set);
  SWIG_addvarlink(globals, "MDUpdateAction_DELETE", Swig_var_MDUpdateAction_DELETE_get, Swig_var_MDUpdateAction_DELETE_set);
  SWIG_addvarlink(globals, "MDUpdateAction_DELETE_THRU", Swig_var_MDUpdateAction_DELETE_THRU_get, Swig_var_MDUpdateAction_DELETE_THRU_set);
  SWIG_addvarlink(globals, "MDUpdateAction_DELETE_FROM", Swig_var_MDUpdateAction_DELETE_FROM_get, Swig_var_MDUpdateAction_DELETE_FROM_set);
  SWIG_addvarlink(globals, "MDUpdateAction_OVERLAY", Swig_var_MDUpdateAction_OVERLAY_get, Swig_var_MDUpdateAction_OVERLAY_set);
  SWIG_addvarlink(globals, "MDReqRejReason_UNKNOWN_SYMBOL", Swig_var_MDReqRejReason_UNKNOWN_SYMBOL_get, Swig_var_MDReqRejReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(globals, "MDReqRejReason_DUPLICATE_MD_REQ_ID", Swig_var_MDReqRejReason_DUPLICATE_MD_REQ_ID_get, Swig_var_MDReqRejReason_DUPLICATE_MD_REQ_ID_set);
  SWIG_addvarlink(globals, "MDReqRejReason_INSUFFICIENT_BANDWIDTH", Swig_var_MDReqRejReason_INSUFFICIENT_BANDWIDTH_get, Swig_var_MDReqRejReason_INSUFFICIENT_BANDWIDTH_set);
  SWIG_addvarlink(globals, "MDReqRejReason_INSUFFICIENT_PERMISSIONS", Swig_var_MDReqRejReason_INSUFFICIENT_PERMISSIONS_get, Swig_var_MDReqRejReason_INSUFFICIENT_PERMISSIONS_set);
  SWIG_addvarlink(globals, "MDReqRejReason_UNSUPPORTED_SUBSCRIPTION_REQUEST_TYPE", Swig_var_MDReqRejReason_UNSUPPORTED_SUBSCRIPTION_REQUEST_TYPE_get, Swig_var_MDReqRejReason_UNSUPPORTED_SUBSCRIPTION_REQUEST_TYPE_set);
  SWIG_addvarlink(globals, "MDReqRejReason_UNSUPPORTED_MARKET_DEPTH", Swig_var_MDReqRejReason_UNSUPPORTED_MARKET_DEPTH_get, Swig_var_MDReqRejReason_UNSUPPORTED_MARKET_DEPTH_set);
  SWIG_addvarlink(globals, "MDReqRejReason_UNSUPPORTED_MD_UPDATE_TYPE", Swig_var_MDReqRejReason_UNSUPPORTED_MD_UPDATE_TYPE_get, Swig_var_MDReqRejReason_UNSUPPORTED_MD_UPDATE_TYPE_set);
  SWIG_addvarlink(globals, "MDReqRejReason_UNSUPPORTED_AGGREGATED_BOOK", Swig_var_MDReqRejReason_UNSUPPORTED_AGGREGATED_BOOK_get, Swig_var_MDReqRejReason_UNSUPPORTED_AGGREGATED_BOOK_set);
  SWIG_addvarlink(globals, "MDReqRejReason_UNSUPPORTED_MD_ENTRY_TYPE", Swig_var_MDReqRejReason_UNSUPPORTED_MD_ENTRY_TYPE_get, Swig_var_MDReqRejReason_UNSUPPORTED_MD_ENTRY_TYPE_set);
  SWIG_addvarlink(globals, "MDReqRejReason_UNSUPPORTED_MD_IMPLICIT_DELETE", Swig_var_MDReqRejReason_UNSUPPORTED_MD_IMPLICIT_DELETE_get, Swig_var_MDReqRejReason_UNSUPPORTED_MD_IMPLICIT_DELETE_set);
  SWIG_addvarlink(globals, "MDReqRejReason_UNSUPPORTED_OPEN_CLOSE_SETTLE_FLAG", Swig_var_MDReqRejReason_UNSUPPORTED_OPEN_CLOSE_SETTLE_FLAG_get, Swig_var_MDReqRejReason_UNSUPPORTED_OPEN_CLOSE_SETTLE_FLAG_set);
  SWIG_addvarlink(globals, "MDReqRejReason_UNSUPPORTED_SCOPE", Swig_var_MDReqRejReason_UNSUPPORTED_SCOPE_get, Swig_var_MDReqRejReason_UNSUPPORTED_SCOPE_set);
  SWIG_addvarlink(globals, "MDReqRejReason_UNSUPPORTED_TRADING_SESSION_ID", Swig_var_MDReqRejReason_UNSUPPORTED_TRADING_SESSION_ID_get, Swig_var_MDReqRejReason_UNSUPPORTED_TRADING_SESSION_ID_set);
  SWIG_addvarlink(globals, "MDReqRejReason_INSUFFICIENT_CREDIT", Swig_var_MDReqRejReason_INSUFFICIENT_CREDIT_get, Swig_var_MDReqRejReason_INSUFFICIENT_CREDIT_set);
  SWIG_addvarlink(globals, "DeleteReason_CANCELLATION", Swig_var_DeleteReason_CANCELLATION_get, Swig_var_DeleteReason_CANCELLATION_set);
  SWIG_addvarlink(globals, "DeleteReason_ERROR", Swig_var_DeleteReason_ERROR_get, Swig_var_DeleteReason_ERROR_set);
  SWIG_addvarlink(globals, "OpenCloseSettleFlag_DAILY_OPEN", Swig_var_OpenCloseSettleFlag_DAILY_OPEN_get, Swig_var_OpenCloseSettleFlag_DAILY_OPEN_set);
  SWIG_addvarlink(globals, "OpenCloseSettleFlag_SESSION_OPEN", Swig_var_OpenCloseSettleFlag_SESSION_OPEN_get, Swig_var_OpenCloseSettleFlag_SESSION_OPEN_set);
  SWIG_addvarlink(globals, "OpenCloseSettleFlag_DELIVERY_SETTLEMENT_ENTRY", Swig_var_OpenCloseSettleFlag_DELIVERY_SETTLEMENT_ENTRY_get, Swig_var_OpenCloseSettleFlag_DELIVERY_SETTLEMENT_ENTRY_set);
  SWIG_addvarlink(globals, "OpenCloseSettleFlag_EXPECTED_ENTRY", Swig_var_OpenCloseSettleFlag_EXPECTED_ENTRY_get, Swig_var_OpenCloseSettleFlag_EXPECTED_ENTRY_set);
  SWIG_addvarlink(globals, "OpenCloseSettleFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY", Swig_var_OpenCloseSettleFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_get, Swig_var_OpenCloseSettleFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_set);
  SWIG_addvarlink(globals, "FinancialStatus_BANKRUPT", Swig_var_FinancialStatus_BANKRUPT_get, Swig_var_FinancialStatus_BANKRUPT_set);
  SWIG_addvarlink(globals, "FinancialStatus_PENDING_DELISTING", Swig_var_FinancialStatus_PENDING_DELISTING_get, Swig_var_FinancialStatus_PENDING_DELISTING_set);
  SWIG_addvarlink(globals, "FinancialStatus_RESTRICTED", Swig_var_FinancialStatus_RESTRICTED_get, Swig_var_FinancialStatus_RESTRICTED_set);
  SWIG_addvarlink(globals, "CorporateAction_EX_DIVIDEND", Swig_var_CorporateAction_EX_DIVIDEND_get, Swig_var_CorporateAction_EX_DIVIDEND_set);
  SWIG_addvarlink(globals, "CorporateAction_EX_DISTRIBUTION", Swig_var_CorporateAction_EX_DISTRIBUTION_get, Swig_var_CorporateAction_EX_DISTRIBUTION_set);
  SWIG_addvarlink(globals, "CorporateAction_EX_RIGHTS", Swig_var_CorporateAction_EX_RIGHTS_get, Swig_var_CorporateAction_EX_RIGHTS_set);
  SWIG_addvarlink(globals, "CorporateAction_NEW", Swig_var_CorporateAction_NEW_get, Swig_var_CorporateAction_NEW_set);
  SWIG_addvarlink(globals, "CorporateAction_EX_INTEREST", Swig_var_CorporateAction_EX_INTEREST_get, Swig_var_CorporateAction_EX_INTEREST_set);
  SWIG_addvarlink(globals, "CorporateAction_CASH_DIVIDEND", Swig_var_CorporateAction_CASH_DIVIDEND_get, Swig_var_CorporateAction_CASH_DIVIDEND_set);
  SWIG_addvarlink(globals, "CorporateAction_STOCK_DIVIDEND", Swig_var_CorporateAction_STOCK_DIVIDEND_get, Swig_var_CorporateAction_STOCK_DIVIDEND_set);
  SWIG_addvarlink(globals, "CorporateAction_NON_INTEGER_STOCK_SPLIT", Swig_var_CorporateAction_NON_INTEGER_STOCK_SPLIT_get, Swig_var_CorporateAction_NON_INTEGER_STOCK_SPLIT_set);
  SWIG_addvarlink(globals, "CorporateAction_REVERSE_STOCK_SPLIT", Swig_var_CorporateAction_REVERSE_STOCK_SPLIT_get, Swig_var_CorporateAction_REVERSE_STOCK_SPLIT_set);
  SWIG_addvarlink(globals, "CorporateAction_STANDARD_INTEGER_STOCK_SPLIT", Swig_var_CorporateAction_STANDARD_INTEGER_STOCK_SPLIT_get, Swig_var_CorporateAction_STANDARD_INTEGER_STOCK_SPLIT_set);
  SWIG_addvarlink(globals, "CorporateAction_POSITION_CONSOLIDATION", Swig_var_CorporateAction_POSITION_CONSOLIDATION_get, Swig_var_CorporateAction_POSITION_CONSOLIDATION_set);
  SWIG_addvarlink(globals, "CorporateAction_LIQUIDATION_REORGANIZATION", Swig_var_CorporateAction_LIQUIDATION_REORGANIZATION_get, Swig_var_CorporateAction_LIQUIDATION_REORGANIZATION_set);
  SWIG_addvarlink(globals, "CorporateAction_MERGER_REORGANIZATION", Swig_var_CorporateAction_MERGER_REORGANIZATION_get, Swig_var_CorporateAction_MERGER_REORGANIZATION_set);
  SWIG_addvarlink(globals, "CorporateAction_RIGHTS_OFFERING", Swig_var_CorporateAction_RIGHTS_OFFERING_get, Swig_var_CorporateAction_RIGHTS_OFFERING_set);
  SWIG_addvarlink(globals, "CorporateAction_SHAREHOLDER_MEETING", Swig_var_CorporateAction_SHAREHOLDER_MEETING_get, Swig_var_CorporateAction_SHAREHOLDER_MEETING_set);
  SWIG_addvarlink(globals, "CorporateAction_SPINOFF", Swig_var_CorporateAction_SPINOFF_get, Swig_var_CorporateAction_SPINOFF_set);
  SWIG_addvarlink(globals, "CorporateAction_TENDER_OFFER", Swig_var_CorporateAction_TENDER_OFFER_get, Swig_var_CorporateAction_TENDER_OFFER_set);
  SWIG_addvarlink(globals, "CorporateAction_WARRANT", Swig_var_CorporateAction_WARRANT_get, Swig_var_CorporateAction_WARRANT_set);
  SWIG_addvarlink(globals, "CorporateAction_SPECIAL_ACTION", Swig_var_CorporateAction_SPECIAL_ACTION_get, Swig_var_CorporateAction_SPECIAL_ACTION_set);
  SWIG_addvarlink(globals, "CorporateAction_SYMBOL_CONVERSION", Swig_var_CorporateAction_SYMBOL_CONVERSION_get, Swig_var_CorporateAction_SYMBOL_CONVERSION_set);
  SWIG_addvarlink(globals, "CorporateAction_CUSIP", Swig_var_CorporateAction_CUSIP_get, Swig_var_CorporateAction_CUSIP_set);
  SWIG_addvarlink(globals, "CorporateAction_LEAP_ROLLOVER", Swig_var_CorporateAction_LEAP_ROLLOVER_get, Swig_var_CorporateAction_LEAP_ROLLOVER_set);
  SWIG_addvarlink(globals, "CorporateAction_SUCCESSION_EVENT", Swig_var_CorporateAction_SUCCESSION_EVENT_get, Swig_var_CorporateAction_SUCCESSION_EVENT_set);
  SWIG_addvarlink(globals, "QuoteAckStatus_ACCEPTED", Swig_var_QuoteAckStatus_ACCEPTED_get, Swig_var_QuoteAckStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "QuoteAckStatus_CANCEL_FOR_SYMBOL", Swig_var_QuoteAckStatus_CANCEL_FOR_SYMBOL_get, Swig_var_QuoteAckStatus_CANCEL_FOR_SYMBOL_set);
  SWIG_addvarlink(globals, "QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE", Swig_var_QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE_get, Swig_var_QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE_set);
  SWIG_addvarlink(globals, "QuoteAckStatus_CANCELED_FOR_UNDERLYING", Swig_var_QuoteAckStatus_CANCELED_FOR_UNDERLYING_get, Swig_var_QuoteAckStatus_CANCELED_FOR_UNDERLYING_set);
  SWIG_addvarlink(globals, "QuoteAckStatus_CANCELED_ALL", Swig_var_QuoteAckStatus_CANCELED_ALL_get, Swig_var_QuoteAckStatus_CANCELED_ALL_set);
  SWIG_addvarlink(globals, "QuoteAckStatus_REJECTED", Swig_var_QuoteAckStatus_REJECTED_get, Swig_var_QuoteAckStatus_REJECTED_set);
  SWIG_addvarlink(globals, "QuoteAckStatus_RECEIVED_NOT_YET_PROCESSED", Swig_var_QuoteAckStatus_RECEIVED_NOT_YET_PROCESSED_get, Swig_var_QuoteAckStatus_RECEIVED_NOT_YET_PROCESSED_set);
  SWIG_addvarlink(globals, "QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES", Swig_var_QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES_get, Swig_var_QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES_set);
  SWIG_addvarlink(globals, "QuoteCancelType_CANCEL_FOR_SECURITY_TYPE", Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_TYPE_get, Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_TYPE_set);
  SWIG_addvarlink(globals, "QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY", Swig_var_QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY_get, Swig_var_QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "QuoteCancelType_CANCEL_ALL_QUOTES", Swig_var_QuoteCancelType_CANCEL_ALL_QUOTES_get, Swig_var_QuoteCancelType_CANCEL_ALL_QUOTES_set);
  SWIG_addvarlink(globals, "QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTE_ID", Swig_var_QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTE_ID_get, Swig_var_QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTE_ID_set);
  SWIG_addvarlink(globals, "QuoteCancelType_CANCEL_SPECIFIED_SINGLE_QUOTE", Swig_var_QuoteCancelType_CANCEL_SPECIFIED_SINGLE_QUOTE_get, Swig_var_QuoteCancelType_CANCEL_SPECIFIED_SINGLE_QUOTE_set);
  SWIG_addvarlink(globals, "QuoteCancelType_CANCEL_BY_TYPE_OF_QUOTE", Swig_var_QuoteCancelType_CANCEL_BY_TYPE_OF_QUOTE_get, Swig_var_QuoteCancelType_CANCEL_BY_TYPE_OF_QUOTE_set);
  SWIG_addvarlink(globals, "QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER", Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER_get, Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER_set);
  SWIG_addvarlink(globals, "QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY", Swig_var_QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_UNKNOWN_SYMBOL", Swig_var_QuoteRejectReason_UNKNOWN_SYMBOL_get, Swig_var_QuoteRejectReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_EXCHANGE", Swig_var_QuoteRejectReason_EXCHANGE_get, Swig_var_QuoteRejectReason_EXCHANGE_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT", Swig_var_QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get, Swig_var_QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_TOO_LATE_TO_ENTER", Swig_var_QuoteRejectReason_TOO_LATE_TO_ENTER_get, Swig_var_QuoteRejectReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_UNKNOWN_QUOTE", Swig_var_QuoteRejectReason_UNKNOWN_QUOTE_get, Swig_var_QuoteRejectReason_UNKNOWN_QUOTE_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_DUPLICATE_QUOTE", Swig_var_QuoteRejectReason_DUPLICATE_QUOTE_get, Swig_var_QuoteRejectReason_DUPLICATE_QUOTE_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_INVALID_BID", Swig_var_QuoteRejectReason_INVALID_BID_get, Swig_var_QuoteRejectReason_INVALID_BID_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_INVALID_PRICE", Swig_var_QuoteRejectReason_INVALID_PRICE_get, Swig_var_QuoteRejectReason_INVALID_PRICE_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY", Swig_var_QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get, Swig_var_QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_OTHER", Swig_var_QuoteRejectReason_OTHER_get, Swig_var_QuoteRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND", Swig_var_QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get, Swig_var_QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_QUOTE_LOCKED", Swig_var_QuoteRejectReason_QUOTE_LOCKED_get, Swig_var_QuoteRejectReason_QUOTE_LOCKED_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER", Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get, Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY", Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD", Swig_var_QuoteRejectReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD_get, Swig_var_QuoteRejectReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_DEPR", Swig_var_QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_DEPR_get, Swig_var_QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_DEPR_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_REFERENCE_PRICE_NOT_AVAILABLE", Swig_var_QuoteRejectReason_REFERENCE_PRICE_NOT_AVAILABLE_get, Swig_var_QuoteRejectReason_REFERENCE_PRICE_NOT_AVAILABLE_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_INSUFFICIENT_CREDIT_LIMIT", Swig_var_QuoteRejectReason_INSUFFICIENT_CREDIT_LIMIT_get, Swig_var_QuoteRejectReason_INSUFFICIENT_CREDIT_LIMIT_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_EXCEEDED_CLIP_SIZE_LIMIT", Swig_var_QuoteRejectReason_EXCEEDED_CLIP_SIZE_LIMIT_get, Swig_var_QuoteRejectReason_EXCEEDED_CLIP_SIZE_LIMIT_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT", Swig_var_QuoteRejectReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT_get, Swig_var_QuoteRejectReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_EXCEEDED_DV01_PV01_LIMIT", Swig_var_QuoteRejectReason_EXCEEDED_DV01_PV01_LIMIT_get, Swig_var_QuoteRejectReason_EXCEEDED_DV01_PV01_LIMIT_set);
  SWIG_addvarlink(globals, "QuoteRejectReason_EXCEEDED_CS01_LIMIT", Swig_var_QuoteRejectReason_EXCEEDED_CS01_LIMIT_get, Swig_var_QuoteRejectReason_EXCEEDED_CS01_LIMIT_set);
  SWIG_addvarlink(globals, "QuoteResponseLevel_NO_ACKNOWLEDGEMENT", Swig_var_QuoteResponseLevel_NO_ACKNOWLEDGEMENT_get, Swig_var_QuoteResponseLevel_NO_ACKNOWLEDGEMENT_set);
  SWIG_addvarlink(globals, "QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES", Swig_var_QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES_get, Swig_var_QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES_set);
  SWIG_addvarlink(globals, "QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE", Swig_var_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE_get, Swig_var_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE_set);
  SWIG_addvarlink(globals, "QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT", Swig_var_QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_get, Swig_var_QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_set);
  SWIG_addvarlink(globals, "QuoteRequestType_MANUAL", Swig_var_QuoteRequestType_MANUAL_get, Swig_var_QuoteRequestType_MANUAL_set);
  SWIG_addvarlink(globals, "QuoteRequestType_AUTOMATIC", Swig_var_QuoteRequestType_AUTOMATIC_get, Swig_var_QuoteRequestType_AUTOMATIC_set);
  SWIG_addvarlink(globals, "QuoteRequestType_CONFIRM_QUOTE", Swig_var_QuoteRequestType_CONFIRM_QUOTE_get, Swig_var_QuoteRequestType_CONFIRM_QUOTE_set);
  SWIG_addvarlink(globals, "SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS", Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS_get, Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS_set);
  SWIG_addvarlink(globals, "SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_SPECIFICATIONS", Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_SPECIFICATIONS_get, Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_SPECIFICATIONS_set);
  SWIG_addvarlink(globals, "SecurityRequestType_REQUEST_LIST_SECURITY_TYPES", Swig_var_SecurityRequestType_REQUEST_LIST_SECURITY_TYPES_get, Swig_var_SecurityRequestType_REQUEST_LIST_SECURITY_TYPES_set);
  SWIG_addvarlink(globals, "SecurityRequestType_REQUEST_LIST_SECURITIES", Swig_var_SecurityRequestType_REQUEST_LIST_SECURITIES_get, Swig_var_SecurityRequestType_REQUEST_LIST_SECURITIES_set);
  SWIG_addvarlink(globals, "SecurityRequestType_SYMBOL", Swig_var_SecurityRequestType_SYMBOL_get, Swig_var_SecurityRequestType_SYMBOL_set);
  SWIG_addvarlink(globals, "SecurityRequestType_SECURITY_TYPE_AND_OR_CFI_CODE", Swig_var_SecurityRequestType_SECURITY_TYPE_AND_OR_CFI_CODE_get, Swig_var_SecurityRequestType_SECURITY_TYPE_AND_OR_CFI_CODE_set);
  SWIG_addvarlink(globals, "SecurityRequestType_PRODUCT", Swig_var_SecurityRequestType_PRODUCT_get, Swig_var_SecurityRequestType_PRODUCT_set);
  SWIG_addvarlink(globals, "SecurityRequestType_TRADING_SESSION_ID", Swig_var_SecurityRequestType_TRADING_SESSION_ID_get, Swig_var_SecurityRequestType_TRADING_SESSION_ID_set);
  SWIG_addvarlink(globals, "SecurityRequestType_ALL_SECURITIES", Swig_var_SecurityRequestType_ALL_SECURITIES_get, Swig_var_SecurityRequestType_ALL_SECURITIES_set);
  SWIG_addvarlink(globals, "SecurityRequestType_MARKET_ID_OR_MARKET_ID", Swig_var_SecurityRequestType_MARKET_ID_OR_MARKET_ID_get, Swig_var_SecurityRequestType_MARKET_ID_OR_MARKET_ID_set);
  SWIG_addvarlink(globals, "SecurityResponseType_ACCEPT_AS_IS", Swig_var_SecurityResponseType_ACCEPT_AS_IS_get, Swig_var_SecurityResponseType_ACCEPT_AS_IS_set);
  SWIG_addvarlink(globals, "SecurityResponseType_ACCEPT_WITH_REVISIONS", Swig_var_SecurityResponseType_ACCEPT_WITH_REVISIONS_get, Swig_var_SecurityResponseType_ACCEPT_WITH_REVISIONS_set);
  SWIG_addvarlink(globals, "SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST", Swig_var_SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST_get, Swig_var_SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST_set);
  SWIG_addvarlink(globals, "SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST", Swig_var_SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST_get, Swig_var_SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST_set);
  SWIG_addvarlink(globals, "SecurityResponseType_REJECT_SECURITY_PROPOSAL", Swig_var_SecurityResponseType_REJECT_SECURITY_PROPOSAL_get, Swig_var_SecurityResponseType_REJECT_SECURITY_PROPOSAL_set);
  SWIG_addvarlink(globals, "SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA", Swig_var_SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA_get, Swig_var_SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA_set);
  SWIG_addvarlink(globals, "UnsolicitedIndicator_NO", Swig_var_UnsolicitedIndicator_NO_get, Swig_var_UnsolicitedIndicator_NO_set);
  SWIG_addvarlink(globals, "UnsolicitedIndicator_YES", Swig_var_UnsolicitedIndicator_YES_get, Swig_var_UnsolicitedIndicator_YES_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_OPENING_DELAY", Swig_var_SecurityTradingStatus_OPENING_DELAY_get, Swig_var_SecurityTradingStatus_OPENING_DELAY_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL", Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL_get, Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_NO_MARKET_IMBALANCE", Swig_var_SecurityTradingStatus_NO_MARKET_IMBALANCE_get, Swig_var_SecurityTradingStatus_NO_MARKET_IMBALANCE_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE", Swig_var_SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE_get, Swig_var_SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_ITS_PRE_OPENING", Swig_var_SecurityTradingStatus_ITS_PRE_OPENING_get, Swig_var_SecurityTradingStatus_ITS_PRE_OPENING_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_NEW_PRICE_INDICATION", Swig_var_SecurityTradingStatus_NEW_PRICE_INDICATION_get, Swig_var_SecurityTradingStatus_NEW_PRICE_INDICATION_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_TRADE_DISSEMINATION_TIME", Swig_var_SecurityTradingStatus_TRADE_DISSEMINATION_TIME_get, Swig_var_SecurityTradingStatus_TRADE_DISSEMINATION_TIME_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_READY_TO_TRADE", Swig_var_SecurityTradingStatus_READY_TO_TRADE_get, Swig_var_SecurityTradingStatus_READY_TO_TRADE_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING", Swig_var_SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING_get, Swig_var_SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET", Swig_var_SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET_get, Swig_var_SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_TRADING_HALT", Swig_var_SecurityTradingStatus_TRADING_HALT_get, Swig_var_SecurityTradingStatus_TRADING_HALT_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_UNKNOWN_OR_INVALID", Swig_var_SecurityTradingStatus_UNKNOWN_OR_INVALID_get, Swig_var_SecurityTradingStatus_UNKNOWN_OR_INVALID_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_RESUME", Swig_var_SecurityTradingStatus_RESUME_get, Swig_var_SecurityTradingStatus_RESUME_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_NO_OPEN", Swig_var_SecurityTradingStatus_NO_OPEN_get, Swig_var_SecurityTradingStatus_NO_OPEN_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_PRICE_INDICATION", Swig_var_SecurityTradingStatus_PRICE_INDICATION_get, Swig_var_SecurityTradingStatus_PRICE_INDICATION_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_TRADING_RANGE_INDICATION", Swig_var_SecurityTradingStatus_TRADING_RANGE_INDICATION_get, Swig_var_SecurityTradingStatus_TRADING_RANGE_INDICATION_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_MARKET_IMBALANCE_BUY", Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_BUY_get, Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_BUY_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_MARKET_IMBALANCE_SELL", Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_SELL_get, Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_SELL_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY", Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY_get, Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_OPENING_ROTATION", Swig_var_SecurityTradingStatus_OPENING_ROTATION_get, Swig_var_SecurityTradingStatus_OPENING_ROTATION_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_PRE_OPEN", Swig_var_SecurityTradingStatus_PRE_OPEN_get, Swig_var_SecurityTradingStatus_PRE_OPEN_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_FAST_MARKET", Swig_var_SecurityTradingStatus_FAST_MARKET_get, Swig_var_SecurityTradingStatus_FAST_MARKET_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_PRE_CROSS", Swig_var_SecurityTradingStatus_PRE_CROSS_get, Swig_var_SecurityTradingStatus_PRE_CROSS_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_CROSS", Swig_var_SecurityTradingStatus_CROSS_get, Swig_var_SecurityTradingStatus_CROSS_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_POST_CLOSE", Swig_var_SecurityTradingStatus_POST_CLOSE_get, Swig_var_SecurityTradingStatus_POST_CLOSE_set);
  SWIG_addvarlink(globals, "SecurityTradingStatus_NO_CANCEL", Swig_var_SecurityTradingStatus_NO_CANCEL_get, Swig_var_SecurityTradingStatus_NO_CANCEL_set);
  SWIG_addvarlink(globals, "HaltReasonChar_NEWS_DISSEMINATION", Swig_var_HaltReasonChar_NEWS_DISSEMINATION_get, Swig_var_HaltReasonChar_NEWS_DISSEMINATION_set);
  SWIG_addvarlink(globals, "HaltReasonChar_ORDER_INFLUX", Swig_var_HaltReasonChar_ORDER_INFLUX_get, Swig_var_HaltReasonChar_ORDER_INFLUX_set);
  SWIG_addvarlink(globals, "HaltReasonChar_ORDER_IMBALANCE", Swig_var_HaltReasonChar_ORDER_IMBALANCE_get, Swig_var_HaltReasonChar_ORDER_IMBALANCE_set);
  SWIG_addvarlink(globals, "HaltReasonChar_ADDITIONAL_INFORMATION", Swig_var_HaltReasonChar_ADDITIONAL_INFORMATION_get, Swig_var_HaltReasonChar_ADDITIONAL_INFORMATION_set);
  SWIG_addvarlink(globals, "HaltReasonChar_NEWS_PENDING", Swig_var_HaltReasonChar_NEWS_PENDING_get, Swig_var_HaltReasonChar_NEWS_PENDING_set);
  SWIG_addvarlink(globals, "HaltReasonChar_EQUIPMENT_CHANGEOVER", Swig_var_HaltReasonChar_EQUIPMENT_CHANGEOVER_get, Swig_var_HaltReasonChar_EQUIPMENT_CHANGEOVER_set);
  SWIG_addvarlink(globals, "HaltReasonChar_NEW_PENDING", Swig_var_HaltReasonChar_NEW_PENDING_get, Swig_var_HaltReasonChar_NEW_PENDING_set);
  SWIG_addvarlink(globals, "InViewOfCommon_NO", Swig_var_InViewOfCommon_NO_get, Swig_var_InViewOfCommon_NO_set);
  SWIG_addvarlink(globals, "InViewOfCommon_YES", Swig_var_InViewOfCommon_YES_get, Swig_var_InViewOfCommon_YES_set);
  SWIG_addvarlink(globals, "DueToRelated_NO", Swig_var_DueToRelated_NO_get, Swig_var_DueToRelated_NO_set);
  SWIG_addvarlink(globals, "DueToRelated_YES", Swig_var_DueToRelated_YES_get, Swig_var_DueToRelated_YES_set);
  SWIG_addvarlink(globals, "Adjustment_CANCEL", Swig_var_Adjustment_CANCEL_get, Swig_var_Adjustment_CANCEL_set);
  SWIG_addvarlink(globals, "Adjustment_ERROR", Swig_var_Adjustment_ERROR_get, Swig_var_Adjustment_ERROR_set);
  SWIG_addvarlink(globals, "Adjustment_CORRECTION", Swig_var_Adjustment_CORRECTION_get, Swig_var_Adjustment_CORRECTION_set);
  SWIG_addvarlink(globals, "TradingSessionID_DAY", Swig_var_TradingSessionID_DAY_get, Swig_var_TradingSessionID_DAY_set);
  SWIG_addvarlink(globals, "TradingSessionID_HALF_DAY", Swig_var_TradingSessionID_HALF_DAY_get, Swig_var_TradingSessionID_HALF_DAY_set);
  SWIG_addvarlink(globals, "TradingSessionID_MORNING", Swig_var_TradingSessionID_MORNING_get, Swig_var_TradingSessionID_MORNING_set);
  SWIG_addvarlink(globals, "TradingSessionID_AFTERNOON", Swig_var_TradingSessionID_AFTERNOON_get, Swig_var_TradingSessionID_AFTERNOON_set);
  SWIG_addvarlink(globals, "TradingSessionID_EVENING", Swig_var_TradingSessionID_EVENING_get, Swig_var_TradingSessionID_EVENING_set);
  SWIG_addvarlink(globals, "TradingSessionID_AFTER_HOURS", Swig_var_TradingSessionID_AFTER_HOURS_get, Swig_var_TradingSessionID_AFTER_HOURS_set);
  SWIG_addvarlink(globals, "TradingSessionID_HOLIDAY", Swig_var_TradingSessionID_HOLIDAY_get, Swig_var_TradingSessionID_HOLIDAY_set);
  SWIG_addvarlink(globals, "TradSesMethod_ELECTRONIC", Swig_var_TradSesMethod_ELECTRONIC_get, Swig_var_TradSesMethod_ELECTRONIC_set);
  SWIG_addvarlink(globals, "TradSesMethod_OPEN_OUTCRY", Swig_var_TradSesMethod_OPEN_OUTCRY_get, Swig_var_TradSesMethod_OPEN_OUTCRY_set);
  SWIG_addvarlink(globals, "TradSesMethod_TWO_PARTY", Swig_var_TradSesMethod_TWO_PARTY_get, Swig_var_TradSesMethod_TWO_PARTY_set);
  SWIG_addvarlink(globals, "TradSesMethod_VOICE", Swig_var_TradSesMethod_VOICE_get, Swig_var_TradSesMethod_VOICE_set);
  SWIG_addvarlink(globals, "TradSesMode_TESTING", Swig_var_TradSesMode_TESTING_get, Swig_var_TradSesMode_TESTING_set);
  SWIG_addvarlink(globals, "TradSesMode_SIMULATED", Swig_var_TradSesMode_SIMULATED_get, Swig_var_TradSesMode_SIMULATED_set);
  SWIG_addvarlink(globals, "TradSesMode_PRODUCTION", Swig_var_TradSesMode_PRODUCTION_get, Swig_var_TradSesMode_PRODUCTION_set);
  SWIG_addvarlink(globals, "TradSesStatus_HALTED", Swig_var_TradSesStatus_HALTED_get, Swig_var_TradSesStatus_HALTED_set);
  SWIG_addvarlink(globals, "TradSesStatus_OPEN", Swig_var_TradSesStatus_OPEN_get, Swig_var_TradSesStatus_OPEN_set);
  SWIG_addvarlink(globals, "TradSesStatus_CLOSED", Swig_var_TradSesStatus_CLOSED_get, Swig_var_TradSesStatus_CLOSED_set);
  SWIG_addvarlink(globals, "TradSesStatus_PRE_OPEN", Swig_var_TradSesStatus_PRE_OPEN_get, Swig_var_TradSesStatus_PRE_OPEN_set);
  SWIG_addvarlink(globals, "TradSesStatus_PRE_CLOSE", Swig_var_TradSesStatus_PRE_CLOSE_get, Swig_var_TradSesStatus_PRE_CLOSE_set);
  SWIG_addvarlink(globals, "TradSesStatus_REQUEST_REJECTED", Swig_var_TradSesStatus_REQUEST_REJECTED_get, Swig_var_TradSesStatus_REQUEST_REJECTED_set);
  SWIG_addvarlink(globals, "TradSesStatus_UNKNOWN", Swig_var_TradSesStatus_UNKNOWN_get, Swig_var_TradSesStatus_UNKNOWN_set);
  SWIG_addvarlink(globals, "QuoteEntryRejectReason_UNKNOWN_SYMBOL", Swig_var_QuoteEntryRejectReason_UNKNOWN_SYMBOL_get, Swig_var_QuoteEntryRejectReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(globals, "QuoteEntryRejectReason_EXCHANGE", Swig_var_QuoteEntryRejectReason_EXCHANGE_get, Swig_var_QuoteEntryRejectReason_EXCHANGE_set);
  SWIG_addvarlink(globals, "QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT", Swig_var_QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT_get, Swig_var_QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(globals, "QuoteEntryRejectReason_TOO_LATE_TO_ENTER", Swig_var_QuoteEntryRejectReason_TOO_LATE_TO_ENTER_get, Swig_var_QuoteEntryRejectReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(globals, "QuoteEntryRejectReason_UNKNOWN_QUOTE", Swig_var_QuoteEntryRejectReason_UNKNOWN_QUOTE_get, Swig_var_QuoteEntryRejectReason_UNKNOWN_QUOTE_set);
  SWIG_addvarlink(globals, "QuoteEntryRejectReason_DUPLICATE_QUOTE", Swig_var_QuoteEntryRejectReason_DUPLICATE_QUOTE_get, Swig_var_QuoteEntryRejectReason_DUPLICATE_QUOTE_set);
  SWIG_addvarlink(globals, "QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD", Swig_var_QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD_get, Swig_var_QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD_set);
  SWIG_addvarlink(globals, "QuoteEntryRejectReason_INVALID_PRICE", Swig_var_QuoteEntryRejectReason_INVALID_PRICE_get, Swig_var_QuoteEntryRejectReason_INVALID_PRICE_set);
  SWIG_addvarlink(globals, "QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY", Swig_var_QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get, Swig_var_QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_set);
  SWIG_addvarlink(globals, "BidRequestTransType_CANCEL", Swig_var_BidRequestTransType_CANCEL_get, Swig_var_BidRequestTransType_CANCEL_set);
  SWIG_addvarlink(globals, "BidRequestTransType_NEW", Swig_var_BidRequestTransType_NEW_get, Swig_var_BidRequestTransType_NEW_set);
  SWIG_addvarlink(globals, "SolicitedFlag_NO", Swig_var_SolicitedFlag_NO_get, Swig_var_SolicitedFlag_NO_set);
  SWIG_addvarlink(globals, "SolicitedFlag_YES", Swig_var_SolicitedFlag_YES_get, Swig_var_SolicitedFlag_YES_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_GT_CORPORATE_ACTION", Swig_var_ExecRestatementReason_GT_CORPORATE_ACTION_get, Swig_var_ExecRestatementReason_GT_CORPORATE_ACTION_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_GT_RENEWAL", Swig_var_ExecRestatementReason_GT_RENEWAL_get, Swig_var_ExecRestatementReason_GT_RENEWAL_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_VERBAL_CHANGE", Swig_var_ExecRestatementReason_VERBAL_CHANGE_get, Swig_var_ExecRestatementReason_VERBAL_CHANGE_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_REPRICING_OF_ORDER", Swig_var_ExecRestatementReason_REPRICING_OF_ORDER_get, Swig_var_ExecRestatementReason_REPRICING_OF_ORDER_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_BROKER_OPTION", Swig_var_ExecRestatementReason_BROKER_OPTION_get, Swig_var_ExecRestatementReason_BROKER_OPTION_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_PARTIAL_DECLINE_OF_ORDER_QTY", Swig_var_ExecRestatementReason_PARTIAL_DECLINE_OF_ORDER_QTY_get, Swig_var_ExecRestatementReason_PARTIAL_DECLINE_OF_ORDER_QTY_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE", Swig_var_ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE_get, Swig_var_ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_MARKET", Swig_var_ExecRestatementReason_MARKET_get, Swig_var_ExecRestatementReason_MARKET_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_CANCEL_ON_TRADING_HALT", Swig_var_ExecRestatementReason_CANCEL_ON_TRADING_HALT_get, Swig_var_ExecRestatementReason_CANCEL_ON_TRADING_HALT_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_CANCELED", Swig_var_ExecRestatementReason_CANCELED_get, Swig_var_ExecRestatementReason_CANCELED_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_WAREHOUSE_RECAP", Swig_var_ExecRestatementReason_WAREHOUSE_RECAP_get, Swig_var_ExecRestatementReason_WAREHOUSE_RECAP_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_OTHER", Swig_var_ExecRestatementReason_OTHER_get, Swig_var_ExecRestatementReason_OTHER_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_PEG_REFRESH", Swig_var_ExecRestatementReason_PEG_REFRESH_get, Swig_var_ExecRestatementReason_PEG_REFRESH_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_CANCEL_ON_CONNECTION_LOSS", Swig_var_ExecRestatementReason_CANCEL_ON_CONNECTION_LOSS_get, Swig_var_ExecRestatementReason_CANCEL_ON_CONNECTION_LOSS_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_CANCEL_ON_LOGOUT", Swig_var_ExecRestatementReason_CANCEL_ON_LOGOUT_get, Swig_var_ExecRestatementReason_CANCEL_ON_LOGOUT_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_ASSIGN_TIME_PRIORITY", Swig_var_ExecRestatementReason_ASSIGN_TIME_PRIORITY_get, Swig_var_ExecRestatementReason_ASSIGN_TIME_PRIORITY_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_CANCELLED_FOR_TRADE_PRICE_VIOLATION", Swig_var_ExecRestatementReason_CANCELLED_FOR_TRADE_PRICE_VIOLATION_get, Swig_var_ExecRestatementReason_CANCELLED_FOR_TRADE_PRICE_VIOLATION_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_CANCELLED_FOR_CROSS_IMBALANCE", Swig_var_ExecRestatementReason_CANCELLED_FOR_CROSS_IMBALANCE_get, Swig_var_ExecRestatementReason_CANCELLED_FOR_CROSS_IMBALANCE_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_CXLD_SMP", Swig_var_ExecRestatementReason_CXLD_SMP_get, Swig_var_ExecRestatementReason_CXLD_SMP_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_CXLD_SMP_AGGRESSIVE", Swig_var_ExecRestatementReason_CXLD_SMP_AGGRESSIVE_get, Swig_var_ExecRestatementReason_CXLD_SMP_AGGRESSIVE_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_CXLD_SMP_PASSIVE", Swig_var_ExecRestatementReason_CXLD_SMP_PASSIVE_get, Swig_var_ExecRestatementReason_CXLD_SMP_PASSIVE_set);
  SWIG_addvarlink(globals, "ExecRestatementReason_CXLD_SMP_AGGRESSIVE_PASSIVE", Swig_var_ExecRestatementReason_CXLD_SMP_AGGRESSIVE_PASSIVE_get, Swig_var_ExecRestatementReason_CXLD_SMP_AGGRESSIVE_PASSIVE_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_OTHER", Swig_var_BusinessRejectReason_OTHER_get, Swig_var_BusinessRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_UNKNOWN_ID", Swig_var_BusinessRejectReason_UNKNOWN_ID_get, Swig_var_BusinessRejectReason_UNKNOWN_ID_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_UNKNOWN_SECURITY", Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_get, Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE", Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_get, Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_APPLICATION_NOT_AVAILABLE", Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_get, Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING", Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_get, Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_DELIVER_TO_FIRM_NOT_AVAILABLE_AT_THIS_TIME", Swig_var_BusinessRejectReason_DELIVER_TO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_get, Swig_var_BusinessRejectReason_DELIVER_TO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_NOT_AUTHORIZED", Swig_var_BusinessRejectReason_NOT_AUTHORIZED_get, Swig_var_BusinessRejectReason_NOT_AUTHORIZED_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_INVALID_PRICE_INCREMENT", Swig_var_BusinessRejectReason_INVALID_PRICE_INCREMENT_get, Swig_var_BusinessRejectReason_INVALID_PRICE_INCREMENT_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_THROTTLE_LIMIT_EXCEEDED", Swig_var_BusinessRejectReason_THROTTLE_LIMIT_EXCEEDED_get, Swig_var_BusinessRejectReason_THROTTLE_LIMIT_EXCEEDED_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_THROTTLE_LIMIT_EXCEEDED_SESSION_DISCONNECTED", Swig_var_BusinessRejectReason_THROTTLE_LIMIT_EXCEEDED_SESSION_DISCONNECTED_get, Swig_var_BusinessRejectReason_THROTTLE_LIMIT_EXCEEDED_SESSION_DISCONNECTED_set);
  SWIG_addvarlink(globals, "BusinessRejectReason_THROTTLED_MESSAGES_REJECTED_ON_REQUEST", Swig_var_BusinessRejectReason_THROTTLED_MESSAGES_REJECTED_ON_REQUEST_get, Swig_var_BusinessRejectReason_THROTTLED_MESSAGES_REJECTED_ON_REQUEST_set);
  SWIG_addvarlink(globals, "MsgDirection_RECEIVE", Swig_var_MsgDirection_RECEIVE_get, Swig_var_MsgDirection_RECEIVE_set);
  SWIG_addvarlink(globals, "MsgDirection_SEND", Swig_var_MsgDirection_SEND_get, Swig_var_MsgDirection_SEND_set);
  SWIG_addvarlink(globals, "DiscretionInst_RELATED_TO_DISPLAYED_PRICE", Swig_var_DiscretionInst_RELATED_TO_DISPLAYED_PRICE_get, Swig_var_DiscretionInst_RELATED_TO_DISPLAYED_PRICE_set);
  SWIG_addvarlink(globals, "DiscretionInst_RELATED_TO_MARKET_PRICE", Swig_var_DiscretionInst_RELATED_TO_MARKET_PRICE_get, Swig_var_DiscretionInst_RELATED_TO_MARKET_PRICE_set);
  SWIG_addvarlink(globals, "DiscretionInst_RELATED_TO_PRIMARY_PRICE", Swig_var_DiscretionInst_RELATED_TO_PRIMARY_PRICE_get, Swig_var_DiscretionInst_RELATED_TO_PRIMARY_PRICE_set);
  SWIG_addvarlink(globals, "DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE", Swig_var_DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE_get, Swig_var_DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE_set);
  SWIG_addvarlink(globals, "DiscretionInst_RELATED_TO_MIDPOINT_PRICE", Swig_var_DiscretionInst_RELATED_TO_MIDPOINT_PRICE_get, Swig_var_DiscretionInst_RELATED_TO_MIDPOINT_PRICE_set);
  SWIG_addvarlink(globals, "DiscretionInst_RELATED_TO_LAST_TRADE_PRICE", Swig_var_DiscretionInst_RELATED_TO_LAST_TRADE_PRICE_get, Swig_var_DiscretionInst_RELATED_TO_LAST_TRADE_PRICE_set);
  SWIG_addvarlink(globals, "DiscretionInst_RELATED_TO_VWAP", Swig_var_DiscretionInst_RELATED_TO_VWAP_get, Swig_var_DiscretionInst_RELATED_TO_VWAP_set);
  SWIG_addvarlink(globals, "DiscretionInst_AVERAGE_PRICE_GUARANTEE", Swig_var_DiscretionInst_AVERAGE_PRICE_GUARANTEE_get, Swig_var_DiscretionInst_AVERAGE_PRICE_GUARANTEE_set);
  SWIG_addvarlink(globals, "BidType_NON_DISCLOSED", Swig_var_BidType_NON_DISCLOSED_get, Swig_var_BidType_NON_DISCLOSED_set);
  SWIG_addvarlink(globals, "BidType_DISCLOSED", Swig_var_BidType_DISCLOSED_get, Swig_var_BidType_DISCLOSED_set);
  SWIG_addvarlink(globals, "BidType_NO_BIDDING_PROCESS", Swig_var_BidType_NO_BIDDING_PROCESS_get, Swig_var_BidType_NO_BIDDING_PROCESS_set);
  SWIG_addvarlink(globals, "BidDescriptorType_INDEX", Swig_var_BidDescriptorType_INDEX_get, Swig_var_BidDescriptorType_INDEX_set);
  SWIG_addvarlink(globals, "BidDescriptorType_COUNTRY", Swig_var_BidDescriptorType_COUNTRY_get, Swig_var_BidDescriptorType_COUNTRY_set);
  SWIG_addvarlink(globals, "BidDescriptorType_SECTOR", Swig_var_BidDescriptorType_SECTOR_get, Swig_var_BidDescriptorType_SECTOR_set);
  SWIG_addvarlink(globals, "SideValueInd_SIDE_VALUE1", Swig_var_SideValueInd_SIDE_VALUE1_get, Swig_var_SideValueInd_SIDE_VALUE1_set);
  SWIG_addvarlink(globals, "SideValueInd_SIDE_VALUE2", Swig_var_SideValueInd_SIDE_VALUE2_get, Swig_var_SideValueInd_SIDE_VALUE2_set);
  SWIG_addvarlink(globals, "LiquidityIndType_FIVE_DAY_MOVING_AVERAGE", Swig_var_LiquidityIndType_FIVE_DAY_MOVING_AVERAGE_get, Swig_var_LiquidityIndType_FIVE_DAY_MOVING_AVERAGE_set);
  SWIG_addvarlink(globals, "LiquidityIndType_TWENTY_DAY_MOVING_AVERAGE", Swig_var_LiquidityIndType_TWENTY_DAY_MOVING_AVERAGE_get, Swig_var_LiquidityIndType_TWENTY_DAY_MOVING_AVERAGE_set);
  SWIG_addvarlink(globals, "LiquidityIndType_NORMAL_MARKET_SIZE", Swig_var_LiquidityIndType_NORMAL_MARKET_SIZE_get, Swig_var_LiquidityIndType_NORMAL_MARKET_SIZE_set);
  SWIG_addvarlink(globals, "LiquidityIndType_OTHER", Swig_var_LiquidityIndType_OTHER_get, Swig_var_LiquidityIndType_OTHER_set);
  SWIG_addvarlink(globals, "ExchangeForPhysical_NO", Swig_var_ExchangeForPhysical_NO_get, Swig_var_ExchangeForPhysical_NO_set);
  SWIG_addvarlink(globals, "ExchangeForPhysical_YES", Swig_var_ExchangeForPhysical_YES_get, Swig_var_ExchangeForPhysical_YES_set);
  SWIG_addvarlink(globals, "ProgRptReqs_BUY_SIDE_REQUESTS", Swig_var_ProgRptReqs_BUY_SIDE_REQUESTS_get, Swig_var_ProgRptReqs_BUY_SIDE_REQUESTS_set);
  SWIG_addvarlink(globals, "ProgRptReqs_SELL_SIDE_SENDS", Swig_var_ProgRptReqs_SELL_SIDE_SENDS_get, Swig_var_ProgRptReqs_SELL_SIDE_SENDS_set);
  SWIG_addvarlink(globals, "ProgRptReqs_REAL_TIME_EXECUTION_REPORTS", Swig_var_ProgRptReqs_REAL_TIME_EXECUTION_REPORTS_get, Swig_var_ProgRptReqs_REAL_TIME_EXECUTION_REPORTS_set);
  SWIG_addvarlink(globals, "IncTaxInd_NET", Swig_var_IncTaxInd_NET_get, Swig_var_IncTaxInd_NET_set);
  SWIG_addvarlink(globals, "IncTaxInd_GROSS", Swig_var_IncTaxInd_GROSS_get, Swig_var_IncTaxInd_GROSS_set);
  SWIG_addvarlink(globals, "TradeType_AGENCY", Swig_var_TradeType_AGENCY_get, Swig_var_TradeType_AGENCY_set);
  SWIG_addvarlink(globals, "TradeType_VWAP_GUARANTEE", Swig_var_TradeType_VWAP_GUARANTEE_get, Swig_var_TradeType_VWAP_GUARANTEE_set);
  SWIG_addvarlink(globals, "TradeType_GUARANTEED_CLOSE", Swig_var_TradeType_GUARANTEED_CLOSE_get, Swig_var_TradeType_GUARANTEED_CLOSE_set);
  SWIG_addvarlink(globals, "TradeType_RISK_TRADE", Swig_var_TradeType_RISK_TRADE_get, Swig_var_TradeType_RISK_TRADE_set);
  SWIG_addvarlink(globals, "BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION", Swig_var_BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION_get, Swig_var_BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION_set);
  SWIG_addvarlink(globals, "BasisPxType_CLOSING_PRICE", Swig_var_BasisPxType_CLOSING_PRICE_get, Swig_var_BasisPxType_CLOSING_PRICE_set);
  SWIG_addvarlink(globals, "BasisPxType_CURRENT_PRICE", Swig_var_BasisPxType_CURRENT_PRICE_get, Swig_var_BasisPxType_CURRENT_PRICE_set);
  SWIG_addvarlink(globals, "BasisPxType_SQ", Swig_var_BasisPxType_SQ_get, Swig_var_BasisPxType_SQ_set);
  SWIG_addvarlink(globals, "BasisPxType_VWAP_THROUGH_A_DAY", Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_get, Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_set);
  SWIG_addvarlink(globals, "BasisPxType_VWAP_THROUGH_A_MORNING_SESSION", Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_get, Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_set);
  SWIG_addvarlink(globals, "BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION", Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_get, Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_set);
  SWIG_addvarlink(globals, "BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT", Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_get, Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_set);
  SWIG_addvarlink(globals, "BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT", Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_get, Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_set);
  SWIG_addvarlink(globals, "BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT", Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_get, Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_set);
  SWIG_addvarlink(globals, "BasisPxType_STRIKE", Swig_var_BasisPxType_STRIKE_get, Swig_var_BasisPxType_STRIKE_set);
  SWIG_addvarlink(globals, "BasisPxType_OPEN", Swig_var_BasisPxType_OPEN_get, Swig_var_BasisPxType_OPEN_set);
  SWIG_addvarlink(globals, "BasisPxType_OTHERS", Swig_var_BasisPxType_OTHERS_get, Swig_var_BasisPxType_OTHERS_set);
  SWIG_addvarlink(globals, "PriceType_PERCENTAGE", Swig_var_PriceType_PERCENTAGE_get, Swig_var_PriceType_PERCENTAGE_set);
  SWIG_addvarlink(globals, "PriceType_PER_UNIT", Swig_var_PriceType_PER_UNIT_get, Swig_var_PriceType_PER_UNIT_set);
  SWIG_addvarlink(globals, "PriceType_FIXED_AMOUNT", Swig_var_PriceType_FIXED_AMOUNT_get, Swig_var_PriceType_FIXED_AMOUNT_set);
  SWIG_addvarlink(globals, "PriceType_DISCOUNT", Swig_var_PriceType_DISCOUNT_get, Swig_var_PriceType_DISCOUNT_set);
  SWIG_addvarlink(globals, "PriceType_SPREAD", Swig_var_PriceType_SPREAD_get, Swig_var_PriceType_SPREAD_set);
  SWIG_addvarlink(globals, "PriceType_TED_PRICE", Swig_var_PriceType_TED_PRICE_get, Swig_var_PriceType_TED_PRICE_set);
  SWIG_addvarlink(globals, "PriceType_TED_YIELD", Swig_var_PriceType_TED_YIELD_get, Swig_var_PriceType_TED_YIELD_set);
  SWIG_addvarlink(globals, "PriceType_PREMIUM", Swig_var_PriceType_PREMIUM_get, Swig_var_PriceType_PREMIUM_set);
  SWIG_addvarlink(globals, "PriceType_YIELD", Swig_var_PriceType_YIELD_get, Swig_var_PriceType_YIELD_set);
  SWIG_addvarlink(globals, "PriceType_FIXED_CABINET_TRADE_PRICE", Swig_var_PriceType_FIXED_CABINET_TRADE_PRICE_get, Swig_var_PriceType_FIXED_CABINET_TRADE_PRICE_set);
  SWIG_addvarlink(globals, "PriceType_VARIABLE_CABINET_TRADE_PRICE", Swig_var_PriceType_VARIABLE_CABINET_TRADE_PRICE_get, Swig_var_PriceType_VARIABLE_CABINET_TRADE_PRICE_set);
  SWIG_addvarlink(globals, "PriceType_PRODUCT_TICKS_IN_HALFS", Swig_var_PriceType_PRODUCT_TICKS_IN_HALFS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_HALFS_set);
  SWIG_addvarlink(globals, "PriceType_PRODUCT_TICKS_IN_FOURTHS", Swig_var_PriceType_PRODUCT_TICKS_IN_FOURTHS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_FOURTHS_set);
  SWIG_addvarlink(globals, "PriceType_PRODUCT_TICKS_IN_EIGHTS", Swig_var_PriceType_PRODUCT_TICKS_IN_EIGHTS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_EIGHTS_set);
  SWIG_addvarlink(globals, "PriceType_PRODUCT_TICKS_IN_SIXTEENTHS", Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTEENTHS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTEENTHS_set);
  SWIG_addvarlink(globals, "PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS", Swig_var_PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_set);
  SWIG_addvarlink(globals, "PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS", Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS_set);
  SWIG_addvarlink(globals, "PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS", Swig_var_PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS_set);
  SWIG_addvarlink(globals, "PriceType_PRICE_SPREAD", Swig_var_PriceType_PRICE_SPREAD_get, Swig_var_PriceType_PRICE_SPREAD_set);
  SWIG_addvarlink(globals, "PriceType_PRODUCT_TICKS_IN_HALVES", Swig_var_PriceType_PRODUCT_TICKS_IN_HALVES_get, Swig_var_PriceType_PRODUCT_TICKS_IN_HALVES_set);
  SWIG_addvarlink(globals, "PriceType_PRODUCT_TICKS_IN_EIGHTHS", Swig_var_PriceType_PRODUCT_TICKS_IN_EIGHTHS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_EIGHTHS_set);
  SWIG_addvarlink(globals, "PriceType_PRODUCT_TICKS_IN_SIXTY_FOURTHS", Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTY_FOURTHS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTY_FOURTHS_set);
  SWIG_addvarlink(globals, "PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTHS", Swig_var_PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTHS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTHS_set);
  SWIG_addvarlink(globals, "PriceType_NORMAL_RATE_REPRESENTATION", Swig_var_PriceType_NORMAL_RATE_REPRESENTATION_get, Swig_var_PriceType_NORMAL_RATE_REPRESENTATION_set);
  SWIG_addvarlink(globals, "PriceType_INVERSE_RATE_REPRESENTATION", Swig_var_PriceType_INVERSE_RATE_REPRESENTATION_get, Swig_var_PriceType_INVERSE_RATE_REPRESENTATION_set);
  SWIG_addvarlink(globals, "PriceType_BASIS_POINTS", Swig_var_PriceType_BASIS_POINTS_get, Swig_var_PriceType_BASIS_POINTS_set);
  SWIG_addvarlink(globals, "PriceType_UPFRONT_POINTS", Swig_var_PriceType_UPFRONT_POINTS_get, Swig_var_PriceType_UPFRONT_POINTS_set);
  SWIG_addvarlink(globals, "PriceType_INTEREST_RATE", Swig_var_PriceType_INTEREST_RATE_get, Swig_var_PriceType_INTEREST_RATE_set);
  SWIG_addvarlink(globals, "PriceType_PERCENTAGE_NOTIONAL", Swig_var_PriceType_PERCENTAGE_NOTIONAL_get, Swig_var_PriceType_PERCENTAGE_NOTIONAL_set);
  SWIG_addvarlink(globals, "GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION", Swig_var_GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION_get, Swig_var_GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION_set);
  SWIG_addvarlink(globals, "GTBookingInst_ACCUMULATE_UNTIL_FILLED_OR_EXPIRED", Swig_var_GTBookingInst_ACCUMULATE_UNTIL_FILLED_OR_EXPIRED_get, Swig_var_GTBookingInst_ACCUMULATE_UNTIL_FILLED_OR_EXPIRED_set);
  SWIG_addvarlink(globals, "GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE", Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE_get, Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE_set);
  SWIG_addvarlink(globals, "GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE", Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE_get, Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE_set);
  SWIG_addvarlink(globals, "ListStatusType_ALERT", Swig_var_ListStatusType_ALERT_get, Swig_var_ListStatusType_ALERT_set);
  SWIG_addvarlink(globals, "ListStatusType_EXEC_STARTED", Swig_var_ListStatusType_EXEC_STARTED_get, Swig_var_ListStatusType_EXEC_STARTED_set);
  SWIG_addvarlink(globals, "ListStatusType_TIMED", Swig_var_ListStatusType_TIMED_get, Swig_var_ListStatusType_TIMED_set);
  SWIG_addvarlink(globals, "ListStatusType_RESPONSE", Swig_var_ListStatusType_RESPONSE_get, Swig_var_ListStatusType_RESPONSE_set);
  SWIG_addvarlink(globals, "ListStatusType_ACK", Swig_var_ListStatusType_ACK_get, Swig_var_ListStatusType_ACK_set);
  SWIG_addvarlink(globals, "ListStatusType_ALL_DONE", Swig_var_ListStatusType_ALL_DONE_get, Swig_var_ListStatusType_ALL_DONE_set);
  SWIG_addvarlink(globals, "NetGrossInd_NET", Swig_var_NetGrossInd_NET_get, Swig_var_NetGrossInd_NET_set);
  SWIG_addvarlink(globals, "NetGrossInd_GROSS", Swig_var_NetGrossInd_GROSS_get, Swig_var_NetGrossInd_GROSS_set);
  SWIG_addvarlink(globals, "ListOrderStatus_CANCELLING", Swig_var_ListOrderStatus_CANCELLING_get, Swig_var_ListOrderStatus_CANCELLING_set);
  SWIG_addvarlink(globals, "ListOrderStatus_EXECUTING", Swig_var_ListOrderStatus_EXECUTING_get, Swig_var_ListOrderStatus_EXECUTING_set);
  SWIG_addvarlink(globals, "ListOrderStatus_REJECT", Swig_var_ListOrderStatus_REJECT_get, Swig_var_ListOrderStatus_REJECT_set);
  SWIG_addvarlink(globals, "ListOrderStatus_ALL_DONE", Swig_var_ListOrderStatus_ALL_DONE_get, Swig_var_ListOrderStatus_ALL_DONE_set);
  SWIG_addvarlink(globals, "ListOrderStatus_ALERT", Swig_var_ListOrderStatus_ALERT_get, Swig_var_ListOrderStatus_ALERT_set);
  SWIG_addvarlink(globals, "ListOrderStatus_RECEIVED_FOR_EXECUTION", Swig_var_ListOrderStatus_RECEIVED_FOR_EXECUTION_get, Swig_var_ListOrderStatus_RECEIVED_FOR_EXECUTION_set);
  SWIG_addvarlink(globals, "ListOrderStatus_IN_BIDDING_PROCESS", Swig_var_ListOrderStatus_IN_BIDDING_PROCESS_get, Swig_var_ListOrderStatus_IN_BIDDING_PROCESS_set);
  SWIG_addvarlink(globals, "ListExecInstType_IMMEDIATE", Swig_var_ListExecInstType_IMMEDIATE_get, Swig_var_ListExecInstType_IMMEDIATE_set);
  SWIG_addvarlink(globals, "ListExecInstType_WAIT_FOR_INSTRUCTION", Swig_var_ListExecInstType_WAIT_FOR_INSTRUCTION_get, Swig_var_ListExecInstType_WAIT_FOR_INSTRUCTION_set);
  SWIG_addvarlink(globals, "ListExecInstType_BUY_DRIVEN_CASH_WITHDRAW", Swig_var_ListExecInstType_BUY_DRIVEN_CASH_WITHDRAW_get, Swig_var_ListExecInstType_BUY_DRIVEN_CASH_WITHDRAW_set);
  SWIG_addvarlink(globals, "ListExecInstType_BUY_DRIVEN_CASH_TOP_UP", Swig_var_ListExecInstType_BUY_DRIVEN_CASH_TOP_UP_get, Swig_var_ListExecInstType_BUY_DRIVEN_CASH_TOP_UP_set);
  SWIG_addvarlink(globals, "ListExecInstType_SELL_DRIVEN", Swig_var_ListExecInstType_SELL_DRIVEN_get, Swig_var_ListExecInstType_SELL_DRIVEN_set);
  SWIG_addvarlink(globals, "CxlRejResponseTo_ORDER_CANCEL_REQUEST", Swig_var_CxlRejResponseTo_ORDER_CANCEL_REQUEST_get, Swig_var_CxlRejResponseTo_ORDER_CANCEL_REQUEST_set);
  SWIG_addvarlink(globals, "CxlRejResponseTo_ORDER_CANCEL", Swig_var_CxlRejResponseTo_ORDER_CANCEL_get, Swig_var_CxlRejResponseTo_ORDER_CANCEL_set);
  SWIG_addvarlink(globals, "CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST", Swig_var_CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST_get, Swig_var_CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST_set);
  SWIG_addvarlink(globals, "MultiLegReportingType_SINGLE_SECURITY", Swig_var_MultiLegReportingType_SINGLE_SECURITY_get, Swig_var_MultiLegReportingType_SINGLE_SECURITY_set);
  SWIG_addvarlink(globals, "MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY", Swig_var_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_get, Swig_var_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_set);
  SWIG_addvarlink(globals, "MultiLegReportingType_MULTI_LEG_SECURITY", Swig_var_MultiLegReportingType_MULTI_LEG_SECURITY_get, Swig_var_MultiLegReportingType_MULTI_LEG_SECURITY_set);
  SWIG_addvarlink(globals, "SecurityIDSource_SICOVAM", Swig_var_SecurityIDSource_SICOVAM_get, Swig_var_SecurityIDSource_SICOVAM_set);
  SWIG_addvarlink(globals, "SecurityIDSource_SEDOL", Swig_var_SecurityIDSource_SEDOL_get, Swig_var_SecurityIDSource_SEDOL_set);
  SWIG_addvarlink(globals, "SecurityIDSource_CUSIP", Swig_var_SecurityIDSource_CUSIP_get, Swig_var_SecurityIDSource_CUSIP_set);
  SWIG_addvarlink(globals, "SecurityIDSource_QUIK", Swig_var_SecurityIDSource_QUIK_get, Swig_var_SecurityIDSource_QUIK_set);
  SWIG_addvarlink(globals, "SecurityIDSource_BELGIAN", Swig_var_SecurityIDSource_BELGIAN_get, Swig_var_SecurityIDSource_BELGIAN_set);
  SWIG_addvarlink(globals, "SecurityIDSource_VALOREN", Swig_var_SecurityIDSource_VALOREN_get, Swig_var_SecurityIDSource_VALOREN_set);
  SWIG_addvarlink(globals, "SecurityIDSource_DUTCH", Swig_var_SecurityIDSource_DUTCH_get, Swig_var_SecurityIDSource_DUTCH_set);
  SWIG_addvarlink(globals, "SecurityIDSource_WERTPAPIER", Swig_var_SecurityIDSource_WERTPAPIER_get, Swig_var_SecurityIDSource_WERTPAPIER_set);
  SWIG_addvarlink(globals, "SecurityIDSource_BLOOMBERG_SYMBOL", Swig_var_SecurityIDSource_BLOOMBERG_SYMBOL_get, Swig_var_SecurityIDSource_BLOOMBERG_SYMBOL_set);
  SWIG_addvarlink(globals, "SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION", Swig_var_SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_get, Swig_var_SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_set);
  SWIG_addvarlink(globals, "SecurityIDSource_EXCHANGE_SYMBOL", Swig_var_SecurityIDSource_EXCHANGE_SYMBOL_get, Swig_var_SecurityIDSource_EXCHANGE_SYMBOL_set);
  SWIG_addvarlink(globals, "SecurityIDSource_ISO_COUNTRY_CODE", Swig_var_SecurityIDSource_ISO_COUNTRY_CODE_get, Swig_var_SecurityIDSource_ISO_COUNTRY_CODE_set);
  SWIG_addvarlink(globals, "SecurityIDSource_ISO_CURRENCY_CODE", Swig_var_SecurityIDSource_ISO_CURRENCY_CODE_get, Swig_var_SecurityIDSource_ISO_CURRENCY_CODE_set);
  SWIG_addvarlink(globals, "SecurityIDSource_RIC_CODE", Swig_var_SecurityIDSource_RIC_CODE_get, Swig_var_SecurityIDSource_RIC_CODE_set);
  SWIG_addvarlink(globals, "SecurityIDSource_ISIN_NUMBER", Swig_var_SecurityIDSource_ISIN_NUMBER_get, Swig_var_SecurityIDSource_ISIN_NUMBER_set);
  SWIG_addvarlink(globals, "SecurityIDSource_COMMON", Swig_var_SecurityIDSource_COMMON_get, Swig_var_SecurityIDSource_COMMON_set);
  SWIG_addvarlink(globals, "SecurityIDSource_CLEARING_HOUSE", Swig_var_SecurityIDSource_CLEARING_HOUSE_get, Swig_var_SecurityIDSource_CLEARING_HOUSE_set);
  SWIG_addvarlink(globals, "SecurityIDSource_ISDA_FP_ML_SPECIFICATION", Swig_var_SecurityIDSource_ISDA_FP_ML_SPECIFICATION_get, Swig_var_SecurityIDSource_ISDA_FP_ML_SPECIFICATION_set);
  SWIG_addvarlink(globals, "SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY", Swig_var_SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_get, Swig_var_SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_set);
  SWIG_addvarlink(globals, "SecurityIDSource_ISDA_FP_MLURL", Swig_var_SecurityIDSource_ISDA_FP_MLURL_get, Swig_var_SecurityIDSource_ISDA_FP_MLURL_set);
  SWIG_addvarlink(globals, "SecurityIDSource_LETTER_OF_CREDIT", Swig_var_SecurityIDSource_LETTER_OF_CREDIT_get, Swig_var_SecurityIDSource_LETTER_OF_CREDIT_set);
  SWIG_addvarlink(globals, "SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER", Swig_var_SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_get, Swig_var_SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_set);
  SWIG_addvarlink(globals, "SecurityIDSource_MARKIT_RED_ENTITY_CLIP", Swig_var_SecurityIDSource_MARKIT_RED_ENTITY_CLIP_get, Swig_var_SecurityIDSource_MARKIT_RED_ENTITY_CLIP_set);
  SWIG_addvarlink(globals, "SecurityIDSource_MARKIT_RED_PAIR_CLIP", Swig_var_SecurityIDSource_MARKIT_RED_PAIR_CLIP_get, Swig_var_SecurityIDSource_MARKIT_RED_PAIR_CLIP_set);
  SWIG_addvarlink(globals, "SecurityIDSource_CFTC_COMMODITY_CODE", Swig_var_SecurityIDSource_CFTC_COMMODITY_CODE_get, Swig_var_SecurityIDSource_CFTC_COMMODITY_CODE_set);
  SWIG_addvarlink(globals, "SecurityIDSource_ISDA_COMMODITY_REFERENCE_PRICE", Swig_var_SecurityIDSource_ISDA_COMMODITY_REFERENCE_PRICE_get, Swig_var_SecurityIDSource_ISDA_COMMODITY_REFERENCE_PRICE_set);
  SWIG_addvarlink(globals, "SecurityIDSource_FINANCIAL_INSTRUMENT_GLOBAL_IDENTIFIER", Swig_var_SecurityIDSource_FINANCIAL_INSTRUMENT_GLOBAL_IDENTIFIER_get, Swig_var_SecurityIDSource_FINANCIAL_INSTRUMENT_GLOBAL_IDENTIFIER_set);
  SWIG_addvarlink(globals, "SecurityIDSource_LEGAL_ENTITY_IDENTIFIER", Swig_var_SecurityIDSource_LEGAL_ENTITY_IDENTIFIER_get, Swig_var_SecurityIDSource_LEGAL_ENTITY_IDENTIFIER_set);
  SWIG_addvarlink(globals, "SecurityIDSource_SYNTHETIC", Swig_var_SecurityIDSource_SYNTHETIC_get, Swig_var_SecurityIDSource_SYNTHETIC_set);
  SWIG_addvarlink(globals, "SecurityIDSource_FIDESSA_INSTRUMENT_MNEMONIC", Swig_var_SecurityIDSource_FIDESSA_INSTRUMENT_MNEMONIC_get, Swig_var_SecurityIDSource_FIDESSA_INSTRUMENT_MNEMONIC_set);
  SWIG_addvarlink(globals, "SecurityIDSource_INDEX_NAME", Swig_var_SecurityIDSource_INDEX_NAME_get, Swig_var_SecurityIDSource_INDEX_NAME_set);
  SWIG_addvarlink(globals, "SecurityIDSource_UNIFORM_SYMBOL", Swig_var_SecurityIDSource_UNIFORM_SYMBOL_get, Swig_var_SecurityIDSource_UNIFORM_SYMBOL_set);
  SWIG_addvarlink(globals, "SecurityIDSource_DIGITAL_TOKEN_IDENTIFIER", Swig_var_SecurityIDSource_DIGITAL_TOKEN_IDENTIFIER_get, Swig_var_SecurityIDSource_DIGITAL_TOKEN_IDENTIFIER_set);
  SWIG_addvarlink(globals, "IOIQty_LARGE", Swig_var_IOIQty_LARGE_get, Swig_var_IOIQty_LARGE_set);
  SWIG_addvarlink(globals, "IOIQty_MEDIUM", Swig_var_IOIQty_MEDIUM_get, Swig_var_IOIQty_MEDIUM_set);
  SWIG_addvarlink(globals, "IOIQty_SMALL", Swig_var_IOIQty_SMALL_get, Swig_var_IOIQty_SMALL_set);
  SWIG_addvarlink(globals, "IOIQty_UNDISCLOSED_QUANTITY", Swig_var_IOIQty_UNDISCLOSED_QUANTITY_get, Swig_var_IOIQty_UNDISCLOSED_QUANTITY_set);
  SWIG_addvarlink(globals, "PositionEffect_FIFO", Swig_var_PositionEffect_FIFO_get, Swig_var_PositionEffect_FIFO_set);
  SWIG_addvarlink(globals, "PositionEffect_ROLLED", Swig_var_PositionEffect_ROLLED_get, Swig_var_PositionEffect_ROLLED_set);
  SWIG_addvarlink(globals, "PositionEffect_CLOSE", Swig_var_PositionEffect_CLOSE_get, Swig_var_PositionEffect_CLOSE_set);
  SWIG_addvarlink(globals, "PositionEffect_OPEN", Swig_var_PositionEffect_OPEN_get, Swig_var_PositionEffect_OPEN_set);
  SWIG_addvarlink(globals, "PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN", Swig_var_PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN_get, Swig_var_PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN_set);
  SWIG_addvarlink(globals, "PositionEffect_DEFAULT", Swig_var_PositionEffect_DEFAULT_get, Swig_var_PositionEffect_DEFAULT_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_SWAP", Swig_var_BenchmarkCurveName_SWAP_get, Swig_var_BenchmarkCurveName_SWAP_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_LIBID", Swig_var_BenchmarkCurveName_LIBID_get, Swig_var_BenchmarkCurveName_LIBID_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_OTHER", Swig_var_BenchmarkCurveName_OTHER_get, Swig_var_BenchmarkCurveName_OTHER_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_TREASURY", Swig_var_BenchmarkCurveName_TREASURY_get, Swig_var_BenchmarkCurveName_TREASURY_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_EURIBOR", Swig_var_BenchmarkCurveName_EURIBOR_get, Swig_var_BenchmarkCurveName_EURIBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_PFANDBRIEFE", Swig_var_BenchmarkCurveName_PFANDBRIEFE_get, Swig_var_BenchmarkCurveName_PFANDBRIEFE_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_FUTURE_SWAP", Swig_var_BenchmarkCurveName_FUTURE_SWAP_get, Swig_var_BenchmarkCurveName_FUTURE_SWAP_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_MUNI_AAA", Swig_var_BenchmarkCurveName_MUNI_AAA_get, Swig_var_BenchmarkCurveName_MUNI_AAA_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_LIBOR", Swig_var_BenchmarkCurveName_LIBOR_get, Swig_var_BenchmarkCurveName_LIBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_EONIA", Swig_var_BenchmarkCurveName_EONIA_get, Swig_var_BenchmarkCurveName_EONIA_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_EUREPO", Swig_var_BenchmarkCurveName_EUREPO_get, Swig_var_BenchmarkCurveName_EUREPO_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_SONIA", Swig_var_BenchmarkCurveName_SONIA_get, Swig_var_BenchmarkCurveName_SONIA_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_FED_FUND_RATE_EFFECTIVE", Swig_var_BenchmarkCurveName_FED_FUND_RATE_EFFECTIVE_get, Swig_var_BenchmarkCurveName_FED_FUND_RATE_EFFECTIVE_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_FED_OPEN", Swig_var_BenchmarkCurveName_FED_OPEN_get, Swig_var_BenchmarkCurveName_FED_OPEN_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_AUBSW", Swig_var_BenchmarkCurveName_AUBSW_get, Swig_var_BenchmarkCurveName_AUBSW_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_BUBOR", Swig_var_BenchmarkCurveName_BUBOR_get, Swig_var_BenchmarkCurveName_BUBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_CDOR", Swig_var_BenchmarkCurveName_CDOR_get, Swig_var_BenchmarkCurveName_CDOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_CIBOR", Swig_var_BenchmarkCurveName_CIBOR_get, Swig_var_BenchmarkCurveName_CIBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_EONIASWAP", Swig_var_BenchmarkCurveName_EONIASWAP_get, Swig_var_BenchmarkCurveName_EONIASWAP_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_ESTR", Swig_var_BenchmarkCurveName_ESTR_get, Swig_var_BenchmarkCurveName_ESTR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_EURODOLLAR", Swig_var_BenchmarkCurveName_EURODOLLAR_get, Swig_var_BenchmarkCurveName_EURODOLLAR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_EUROSWISS", Swig_var_BenchmarkCurveName_EUROSWISS_get, Swig_var_BenchmarkCurveName_EUROSWISS_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_GCFREPO", Swig_var_BenchmarkCurveName_GCFREPO_get, Swig_var_BenchmarkCurveName_GCFREPO_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_ISDAFIX", Swig_var_BenchmarkCurveName_ISDAFIX_get, Swig_var_BenchmarkCurveName_ISDAFIX_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_JIBAR", Swig_var_BenchmarkCurveName_JIBAR_get, Swig_var_BenchmarkCurveName_JIBAR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_MOSPRIM", Swig_var_BenchmarkCurveName_MOSPRIM_get, Swig_var_BenchmarkCurveName_MOSPRIM_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_NIBOR", Swig_var_BenchmarkCurveName_NIBOR_get, Swig_var_BenchmarkCurveName_NIBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_PRIBOR", Swig_var_BenchmarkCurveName_PRIBOR_get, Swig_var_BenchmarkCurveName_PRIBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_SOFR", Swig_var_BenchmarkCurveName_SOFR_get, Swig_var_BenchmarkCurveName_SOFR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_STIBOR", Swig_var_BenchmarkCurveName_STIBOR_get, Swig_var_BenchmarkCurveName_STIBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_TELBOR", Swig_var_BenchmarkCurveName_TELBOR_get, Swig_var_BenchmarkCurveName_TELBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_TIBOR", Swig_var_BenchmarkCurveName_TIBOR_get, Swig_var_BenchmarkCurveName_TIBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_WIBOR", Swig_var_BenchmarkCurveName_WIBOR_get, Swig_var_BenchmarkCurveName_WIBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_AONIA", Swig_var_BenchmarkCurveName_AONIA_get, Swig_var_BenchmarkCurveName_AONIA_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_AONIAR", Swig_var_BenchmarkCurveName_AONIAR_get, Swig_var_BenchmarkCurveName_AONIAR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_BKBM", Swig_var_BenchmarkCurveName_BKBM_get, Swig_var_BenchmarkCurveName_BKBM_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_CD19_D", Swig_var_BenchmarkCurveName_CD19_D_get, Swig_var_BenchmarkCurveName_CD19_D_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_CORRA", Swig_var_BenchmarkCurveName_CORRA_get, Swig_var_BenchmarkCurveName_CORRA_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_DIRRTN", Swig_var_BenchmarkCurveName_DIRRTN_get, Swig_var_BenchmarkCurveName_DIRRTN_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_EIBOR", Swig_var_BenchmarkCurveName_EIBOR_get, Swig_var_BenchmarkCurveName_EIBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_FIXING_REPO_RATE", Swig_var_BenchmarkCurveName_FIXING_REPO_RATE_get, Swig_var_BenchmarkCurveName_FIXING_REPO_RATE_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_HIBOR", Swig_var_BenchmarkCurveName_HIBOR_get, Swig_var_BenchmarkCurveName_HIBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_IBR", Swig_var_BenchmarkCurveName_IBR_get, Swig_var_BenchmarkCurveName_IBR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_KLIBOR", Swig_var_BenchmarkCurveName_KLIBOR_get, Swig_var_BenchmarkCurveName_KLIBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_MIBOR", Swig_var_BenchmarkCurveName_MIBOR_get, Swig_var_BenchmarkCurveName_MIBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_NZONIA", Swig_var_BenchmarkCurveName_NZONIA_get, Swig_var_BenchmarkCurveName_NZONIA_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_PHIREF", Swig_var_BenchmarkCurveName_PHIREF_get, Swig_var_BenchmarkCurveName_PHIREF_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_REIBOR", Swig_var_BenchmarkCurveName_REIBOR_get, Swig_var_BenchmarkCurveName_REIBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_SAIBOR", Swig_var_BenchmarkCurveName_SAIBOR_get, Swig_var_BenchmarkCurveName_SAIBOR_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_SARON", Swig_var_BenchmarkCurveName_SARON_get, Swig_var_BenchmarkCurveName_SARON_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_SORA", Swig_var_BenchmarkCurveName_SORA_get, Swig_var_BenchmarkCurveName_SORA_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_TLREF", Swig_var_BenchmarkCurveName_TLREF_get, Swig_var_BenchmarkCurveName_TLREF_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_TIIE", Swig_var_BenchmarkCurveName_TIIE_get, Swig_var_BenchmarkCurveName_TIIE_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_THBFIX", Swig_var_BenchmarkCurveName_THBFIX_get, Swig_var_BenchmarkCurveName_THBFIX_set);
  SWIG_addvarlink(globals, "BenchmarkCurveName_TONAR", Swig_var_BenchmarkCurveName_TONAR_get, Swig_var_BenchmarkCurveName_TONAR_set);
  SWIG_addvarlink(globals, "StipulationType_ABSOLUTE_PREPAYMENT_SPEED", Swig_var_StipulationType_ABSOLUTE_PREPAYMENT_SPEED_get, Swig_var_StipulationType_ABSOLUTE_PREPAYMENT_SPEED_set);
  SWIG_addvarlink(globals, "StipulationType_WEIGHTED_AVERAGE_LOAN_AGE", Swig_var_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_get, Swig_var_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_set);
  SWIG_addvarlink(globals, "StipulationType_WEIGHTED_AVERAGE_MATURITY", Swig_var_StipulationType_WEIGHTED_AVERAGE_MATURITY_get, Swig_var_StipulationType_WEIGHTED_AVERAGE_MATURITY_set);
  SWIG_addvarlink(globals, "StipulationType_CONSTANT_PREPAYMENT_RATE", Swig_var_StipulationType_CONSTANT_PREPAYMENT_RATE_get, Swig_var_StipulationType_CONSTANT_PREPAYMENT_RATE_set);
  SWIG_addvarlink(globals, "StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE", Swig_var_StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE_get, Swig_var_StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(globals, "StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON", Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_get, Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_set);
  SWIG_addvarlink(globals, "StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE", Swig_var_StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_get, Swig_var_StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(globals, "StipulationType_SINGLE_MONTHLY_MORTALITY", Swig_var_StipulationType_SINGLE_MONTHLY_MORTALITY_get, Swig_var_StipulationType_SINGLE_MONTHLY_MORTALITY_set);
  SWIG_addvarlink(globals, "StipulationType_MONTHLY_PREPAYMENT_RATE", Swig_var_StipulationType_MONTHLY_PREPAYMENT_RATE_get, Swig_var_StipulationType_MONTHLY_PREPAYMENT_RATE_set);
  SWIG_addvarlink(globals, "StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE", Swig_var_StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE_get, Swig_var_StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(globals, "StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE", Swig_var_StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE_get, Swig_var_StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(globals, "StipulationType_CONSTANT_PREPAYMENT_PENALTY", Swig_var_StipulationType_CONSTANT_PREPAYMENT_PENALTY_get, Swig_var_StipulationType_CONSTANT_PREPAYMENT_PENALTY_set);
  SWIG_addvarlink(globals, "StipulationType_LOT_VARIANCE", Swig_var_StipulationType_LOT_VARIANCE_get, Swig_var_StipulationType_LOT_VARIANCE_set);
  SWIG_addvarlink(globals, "StipulationType_CONSTANT_PREPAYMENT_YIELD", Swig_var_StipulationType_CONSTANT_PREPAYMENT_YIELD_get, Swig_var_StipulationType_CONSTANT_PREPAYMENT_YIELD_set);
  SWIG_addvarlink(globals, "StipulationType_WEIGHTED_AVERAGE_COUPON", Swig_var_StipulationType_WEIGHTED_AVERAGE_COUPON_get, Swig_var_StipulationType_WEIGHTED_AVERAGE_COUPON_set);
  SWIG_addvarlink(globals, "StipulationType_ISSUE_DATE", Swig_var_StipulationType_ISSUE_DATE_get, Swig_var_StipulationType_ISSUE_DATE_set);
  SWIG_addvarlink(globals, "StipulationType_MATURITY_YEAR_AND_MONTH", Swig_var_StipulationType_MATURITY_YEAR_AND_MONTH_get, Swig_var_StipulationType_MATURITY_YEAR_AND_MONTH_set);
  SWIG_addvarlink(globals, "StipulationType_NUMBER_OF_PIECES", Swig_var_StipulationType_NUMBER_OF_PIECES_get, Swig_var_StipulationType_NUMBER_OF_PIECES_set);
  SWIG_addvarlink(globals, "StipulationType_POOLS_MAXIMUM", Swig_var_StipulationType_POOLS_MAXIMUM_get, Swig_var_StipulationType_POOLS_MAXIMUM_set);
  SWIG_addvarlink(globals, "StipulationType_POOLS_PER_MILLION", Swig_var_StipulationType_POOLS_PER_MILLION_get, Swig_var_StipulationType_POOLS_PER_MILLION_set);
  SWIG_addvarlink(globals, "StipulationType_POOLS_PER_LOT", Swig_var_StipulationType_POOLS_PER_LOT_get, Swig_var_StipulationType_POOLS_PER_LOT_set);
  SWIG_addvarlink(globals, "StipulationType_POOLS_PER_TRADE", Swig_var_StipulationType_POOLS_PER_TRADE_get, Swig_var_StipulationType_POOLS_PER_TRADE_set);
  SWIG_addvarlink(globals, "StipulationType_PRODUCTION_YEAR", Swig_var_StipulationType_PRODUCTION_YEAR_get, Swig_var_StipulationType_PRODUCTION_YEAR_set);
  SWIG_addvarlink(globals, "StipulationType_TRADE_VARIANCE", Swig_var_StipulationType_TRADE_VARIANCE_get, Swig_var_StipulationType_TRADE_VARIANCE_set);
  SWIG_addvarlink(globals, "StipulationType_GEOGRAPHICS", Swig_var_StipulationType_GEOGRAPHICS_get, Swig_var_StipulationType_GEOGRAPHICS_set);
  SWIG_addvarlink(globals, "StipulationType_ALTERNATIVE_MINIMUM_TAX", Swig_var_StipulationType_ALTERNATIVE_MINIMUM_TAX_get, Swig_var_StipulationType_ALTERNATIVE_MINIMUM_TAX_set);
  SWIG_addvarlink(globals, "StipulationType_AUTO_REINVESTMENT", Swig_var_StipulationType_AUTO_REINVESTMENT_get, Swig_var_StipulationType_AUTO_REINVESTMENT_set);
  SWIG_addvarlink(globals, "StipulationType_BANK_QUALIFIED", Swig_var_StipulationType_BANK_QUALIFIED_get, Swig_var_StipulationType_BANK_QUALIFIED_set);
  SWIG_addvarlink(globals, "StipulationType_BARGAIN_CONDITIONS", Swig_var_StipulationType_BARGAIN_CONDITIONS_get, Swig_var_StipulationType_BARGAIN_CONDITIONS_set);
  SWIG_addvarlink(globals, "StipulationType_COUPON_RANGE", Swig_var_StipulationType_COUPON_RANGE_get, Swig_var_StipulationType_COUPON_RANGE_set);
  SWIG_addvarlink(globals, "StipulationType_ISO_CURRENCY_CODE", Swig_var_StipulationType_ISO_CURRENCY_CODE_get, Swig_var_StipulationType_ISO_CURRENCY_CODE_set);
  SWIG_addvarlink(globals, "StipulationType_CUSTOM_START", Swig_var_StipulationType_CUSTOM_START_get, Swig_var_StipulationType_CUSTOM_START_set);
  SWIG_addvarlink(globals, "StipulationType_VALUATION_DISCOUNT", Swig_var_StipulationType_VALUATION_DISCOUNT_get, Swig_var_StipulationType_VALUATION_DISCOUNT_set);
  SWIG_addvarlink(globals, "StipulationType_INSURED", Swig_var_StipulationType_INSURED_get, Swig_var_StipulationType_INSURED_set);
  SWIG_addvarlink(globals, "StipulationType_ISSUER", Swig_var_StipulationType_ISSUER_get, Swig_var_StipulationType_ISSUER_set);
  SWIG_addvarlink(globals, "StipulationType_ISSUE_SIZE_RANGE", Swig_var_StipulationType_ISSUE_SIZE_RANGE_get, Swig_var_StipulationType_ISSUE_SIZE_RANGE_set);
  SWIG_addvarlink(globals, "StipulationType_LOOKBACK_DAYS", Swig_var_StipulationType_LOOKBACK_DAYS_get, Swig_var_StipulationType_LOOKBACK_DAYS_set);
  SWIG_addvarlink(globals, "StipulationType_EXPLICIT_LOT_IDENTIFIER", Swig_var_StipulationType_EXPLICIT_LOT_IDENTIFIER_get, Swig_var_StipulationType_EXPLICIT_LOT_IDENTIFIER_set);
  SWIG_addvarlink(globals, "StipulationType_MATURITY_RANGE", Swig_var_StipulationType_MATURITY_RANGE_get, Swig_var_StipulationType_MATURITY_RANGE_set);
  SWIG_addvarlink(globals, "StipulationType_MAXIMUM_SUBSTITUTIONS", Swig_var_StipulationType_MAXIMUM_SUBSTITUTIONS_get, Swig_var_StipulationType_MAXIMUM_SUBSTITUTIONS_set);
  SWIG_addvarlink(globals, "StipulationType_MINIMUM_QUANTITY", Swig_var_StipulationType_MINIMUM_QUANTITY_get, Swig_var_StipulationType_MINIMUM_QUANTITY_set);
  SWIG_addvarlink(globals, "StipulationType_MINIMUM_INCREMENT", Swig_var_StipulationType_MINIMUM_INCREMENT_get, Swig_var_StipulationType_MINIMUM_INCREMENT_set);
  SWIG_addvarlink(globals, "StipulationType_MINIMUM_DENOMINATION", Swig_var_StipulationType_MINIMUM_DENOMINATION_get, Swig_var_StipulationType_MINIMUM_DENOMINATION_set);
  SWIG_addvarlink(globals, "StipulationType_PAYMENT_FREQUENCY", Swig_var_StipulationType_PAYMENT_FREQUENCY_get, Swig_var_StipulationType_PAYMENT_FREQUENCY_set);
  SWIG_addvarlink(globals, "StipulationType_PRICE_RANGE", Swig_var_StipulationType_PRICE_RANGE_get, Swig_var_StipulationType_PRICE_RANGE_set);
  SWIG_addvarlink(globals, "StipulationType_PRICING_FREQUENCY", Swig_var_StipulationType_PRICING_FREQUENCY_get, Swig_var_StipulationType_PRICING_FREQUENCY_set);
  SWIG_addvarlink(globals, "StipulationType_CALL_PROTECTION", Swig_var_StipulationType_CALL_PROTECTION_get, Swig_var_StipulationType_CALL_PROTECTION_set);
  SWIG_addvarlink(globals, "StipulationType_PURPOSE", Swig_var_StipulationType_PURPOSE_get, Swig_var_StipulationType_PURPOSE_set);
  SWIG_addvarlink(globals, "StipulationType_BENCHMARK_PRICE_SOURCE", Swig_var_StipulationType_BENCHMARK_PRICE_SOURCE_get, Swig_var_StipulationType_BENCHMARK_PRICE_SOURCE_set);
  SWIG_addvarlink(globals, "StipulationType_RATING_SOURCE_AND_RANGE", Swig_var_StipulationType_RATING_SOURCE_AND_RANGE_get, Swig_var_StipulationType_RATING_SOURCE_AND_RANGE_set);
  SWIG_addvarlink(globals, "StipulationType_TYPE_OF_REDEMPTION", Swig_var_StipulationType_TYPE_OF_REDEMPTION_get, Swig_var_StipulationType_TYPE_OF_REDEMPTION_set);
  SWIG_addvarlink(globals, "StipulationType_RESTRICTED", Swig_var_StipulationType_RESTRICTED_get, Swig_var_StipulationType_RESTRICTED_set);
  SWIG_addvarlink(globals, "StipulationType_MARKET_SECTOR", Swig_var_StipulationType_MARKET_SECTOR_get, Swig_var_StipulationType_MARKET_SECTOR_set);
  SWIG_addvarlink(globals, "StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED", Swig_var_StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED_get, Swig_var_StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED_set);
  SWIG_addvarlink(globals, "StipulationType_STRUCTURE", Swig_var_StipulationType_STRUCTURE_get, Swig_var_StipulationType_STRUCTURE_set);
  SWIG_addvarlink(globals, "StipulationType_SUBSTITUTIONS_FREQUENCY", Swig_var_StipulationType_SUBSTITUTIONS_FREQUENCY_get, Swig_var_StipulationType_SUBSTITUTIONS_FREQUENCY_set);
  SWIG_addvarlink(globals, "StipulationType_SUBSTITUTIONS_LEFT", Swig_var_StipulationType_SUBSTITUTIONS_LEFT_get, Swig_var_StipulationType_SUBSTITUTIONS_LEFT_set);
  SWIG_addvarlink(globals, "StipulationType_FREEFORM_TEXT", Swig_var_StipulationType_FREEFORM_TEXT_get, Swig_var_StipulationType_FREEFORM_TEXT_set);
  SWIG_addvarlink(globals, "StipulationType_WHOLE_POOL", Swig_var_StipulationType_WHOLE_POOL_get, Swig_var_StipulationType_WHOLE_POOL_set);
  SWIG_addvarlink(globals, "StipulationType_YIELD_RANGE", Swig_var_StipulationType_YIELD_RANGE_get, Swig_var_StipulationType_YIELD_RANGE_set);
  SWIG_addvarlink(globals, "StipulationType_AVERAGE_FICO_SCORE", Swig_var_StipulationType_AVERAGE_FICO_SCORE_get, Swig_var_StipulationType_AVERAGE_FICO_SCORE_set);
  SWIG_addvarlink(globals, "StipulationType_AVERAGE_LOAN_SIZE", Swig_var_StipulationType_AVERAGE_LOAN_SIZE_get, Swig_var_StipulationType_AVERAGE_LOAN_SIZE_set);
  SWIG_addvarlink(globals, "StipulationType_MAXIMUM_LOAN_BALANCE", Swig_var_StipulationType_MAXIMUM_LOAN_BALANCE_get, Swig_var_StipulationType_MAXIMUM_LOAN_BALANCE_set);
  SWIG_addvarlink(globals, "StipulationType_POOL_IDENTIFIER", Swig_var_StipulationType_POOL_IDENTIFIER_get, Swig_var_StipulationType_POOL_IDENTIFIER_set);
  SWIG_addvarlink(globals, "StipulationType_TYPE_OF_ROLL_TRADE", Swig_var_StipulationType_TYPE_OF_ROLL_TRADE_get, Swig_var_StipulationType_TYPE_OF_ROLL_TRADE_set);
  SWIG_addvarlink(globals, "StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE", Swig_var_StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE_get, Swig_var_StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE_set);
  SWIG_addvarlink(globals, "StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE", Swig_var_StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE_get, Swig_var_StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE_set);
  SWIG_addvarlink(globals, "StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE", Swig_var_StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE_get, Swig_var_StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE_set);
  SWIG_addvarlink(globals, "StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET", Swig_var_StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET_get, Swig_var_StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET_set);
  SWIG_addvarlink(globals, "StipulationType_BROKER_CREDIT", Swig_var_StipulationType_BROKER_CREDIT_get, Swig_var_StipulationType_BROKER_CREDIT_set);
  SWIG_addvarlink(globals, "StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS", Swig_var_StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get, Swig_var_StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS_set);
  SWIG_addvarlink(globals, "StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS", Swig_var_StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get, Swig_var_StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS_set);
  SWIG_addvarlink(globals, "StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY", Swig_var_StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY_get, Swig_var_StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY_set);
  SWIG_addvarlink(globals, "StipulationType_MAXIMUM_ORDER_SIZE", Swig_var_StipulationType_MAXIMUM_ORDER_SIZE_get, Swig_var_StipulationType_MAXIMUM_ORDER_SIZE_set);
  SWIG_addvarlink(globals, "StipulationType_ORDER_QUANTITY_INCREMENT", Swig_var_StipulationType_ORDER_QUANTITY_INCREMENT_get, Swig_var_StipulationType_ORDER_QUANTITY_INCREMENT_set);
  SWIG_addvarlink(globals, "StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR", Swig_var_StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR_get, Swig_var_StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR_set);
  SWIG_addvarlink(globals, "StipulationType_BROKER_SALES_CREDIT_OVERRIDE", Swig_var_StipulationType_BROKER_SALES_CREDIT_OVERRIDE_get, Swig_var_StipulationType_BROKER_SALES_CREDIT_OVERRIDE_set);
  SWIG_addvarlink(globals, "StipulationType_TRADER_CREDIT", Swig_var_StipulationType_TRADER_CREDIT_get, Swig_var_StipulationType_TRADER_CREDIT_set);
  SWIG_addvarlink(globals, "StipulationType_DISCOUNT_RATE", Swig_var_StipulationType_DISCOUNT_RATE_get, Swig_var_StipulationType_DISCOUNT_RATE_set);
  SWIG_addvarlink(globals, "StipulationType_YIELD_TO_MATURITY", Swig_var_StipulationType_YIELD_TO_MATURITY_get, Swig_var_StipulationType_YIELD_TO_MATURITY_set);
  SWIG_addvarlink(globals, "StipulationType_ORIGINAL_AMOUNT", Swig_var_StipulationType_ORIGINAL_AMOUNT_get, Swig_var_StipulationType_ORIGINAL_AMOUNT_set);
  SWIG_addvarlink(globals, "StipulationType_POOL_EFFECTIVE_DATE", Swig_var_StipulationType_POOL_EFFECTIVE_DATE_get, Swig_var_StipulationType_POOL_EFFECTIVE_DATE_set);
  SWIG_addvarlink(globals, "StipulationType_POOL_INITIAL_FACTOR", Swig_var_StipulationType_POOL_INITIAL_FACTOR_get, Swig_var_StipulationType_POOL_INITIAL_FACTOR_set);
  SWIG_addvarlink(globals, "StipulationType_TRANCHE", Swig_var_StipulationType_TRANCHE_get, Swig_var_StipulationType_TRANCHE_set);
  SWIG_addvarlink(globals, "StipulationType_SUBSTITUTION", Swig_var_StipulationType_SUBSTITUTION_get, Swig_var_StipulationType_SUBSTITUTION_set);
  SWIG_addvarlink(globals, "StipulationType_MULTEXCHFLLBCK", Swig_var_StipulationType_MULTEXCHFLLBCK_get, Swig_var_StipulationType_MULTEXCHFLLBCK_set);
  SWIG_addvarlink(globals, "StipulationType_COMPSECFLLBCK", Swig_var_StipulationType_COMPSECFLLBCK_get, Swig_var_StipulationType_COMPSECFLLBCK_set);
  SWIG_addvarlink(globals, "StipulationType_LOCLJRSDCTN", Swig_var_StipulationType_LOCLJRSDCTN_get, Swig_var_StipulationType_LOCLJRSDCTN_set);
  SWIG_addvarlink(globals, "StipulationType_RELVJRSDCTN", Swig_var_StipulationType_RELVJRSDCTN_get, Swig_var_StipulationType_RELVJRSDCTN_set);
  SWIG_addvarlink(globals, "StipulationType_INCURRED_RECOVERY", Swig_var_StipulationType_INCURRED_RECOVERY_get, Swig_var_StipulationType_INCURRED_RECOVERY_set);
  SWIG_addvarlink(globals, "StipulationType_ADDITIONAL_TERM", Swig_var_StipulationType_ADDITIONAL_TERM_get, Swig_var_StipulationType_ADDITIONAL_TERM_set);
  SWIG_addvarlink(globals, "StipulationType_MODIFIED_EQUITY_DELIVERY", Swig_var_StipulationType_MODIFIED_EQUITY_DELIVERY_get, Swig_var_StipulationType_MODIFIED_EQUITY_DELIVERY_set);
  SWIG_addvarlink(globals, "StipulationType_NO_REFERENCE_OBLICATION", Swig_var_StipulationType_NO_REFERENCE_OBLICATION_get, Swig_var_StipulationType_NO_REFERENCE_OBLICATION_set);
  SWIG_addvarlink(globals, "StipulationType_UNKNOWN_REFERENCE_OBLIGATION", Swig_var_StipulationType_UNKNOWN_REFERENCE_OBLIGATION_get, Swig_var_StipulationType_UNKNOWN_REFERENCE_OBLIGATION_set);
  SWIG_addvarlink(globals, "StipulationType_ALL_GUARANTEES", Swig_var_StipulationType_ALL_GUARANTEES_get, Swig_var_StipulationType_ALL_GUARANTEES_set);
  SWIG_addvarlink(globals, "StipulationType_REFERENCE_PRICE", Swig_var_StipulationType_REFERENCE_PRICE_get, Swig_var_StipulationType_REFERENCE_PRICE_set);
  SWIG_addvarlink(globals, "StipulationType_REFERENCE_POLICY", Swig_var_StipulationType_REFERENCE_POLICY_get, Swig_var_StipulationType_REFERENCE_POLICY_set);
  SWIG_addvarlink(globals, "StipulationType_SECURED_LIST", Swig_var_StipulationType_SECURED_LIST_get, Swig_var_StipulationType_SECURED_LIST_set);
  SWIG_addvarlink(globals, "StipulationType_INTEREST_PAYOFF_OF_ROLLING_OR_AMENDING_TRADE", Swig_var_StipulationType_INTEREST_PAYOFF_OF_ROLLING_OR_AMENDING_TRADE_get, Swig_var_StipulationType_INTEREST_PAYOFF_OF_ROLLING_OR_AMENDING_TRADE_set);
  SWIG_addvarlink(globals, "YieldType_TRUE_YIELD", Swig_var_YieldType_TRUE_YIELD_get, Swig_var_YieldType_TRUE_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_PREVIOUS_CLOSE_YIELD", Swig_var_YieldType_PREVIOUS_CLOSE_YIELD_get, Swig_var_YieldType_PREVIOUS_CLOSE_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_TO_LONGEST_AVERAGE", Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_get, Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE", Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_get, Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_TO_MATURITY", Swig_var_YieldType_YIELD_TO_MATURITY_get, Swig_var_YieldType_YIELD_TO_MATURITY_set);
  SWIG_addvarlink(globals, "YieldType_MARK_TO_MARKET_YIELD", Swig_var_YieldType_MARK_TO_MARKET_YIELD_get, Swig_var_YieldType_MARK_TO_MARKET_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_OPEN_AVERAGE_YIELD", Swig_var_YieldType_OPEN_AVERAGE_YIELD_get, Swig_var_YieldType_OPEN_AVERAGE_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_TO_NEXT_PUT", Swig_var_YieldType_YIELD_TO_NEXT_PUT_get, Swig_var_YieldType_YIELD_TO_NEXT_PUT_set);
  SWIG_addvarlink(globals, "YieldType_PROCEEDS_YIELD", Swig_var_YieldType_PROCEEDS_YIELD_get, Swig_var_YieldType_PROCEEDS_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_SEMI_ANNUAL_YIELD", Swig_var_YieldType_SEMI_ANNUAL_YIELD_get, Swig_var_YieldType_SEMI_ANNUAL_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE", Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_get, Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_TO_SHORTEST_AVERAGE", Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_get, Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_set);
  SWIG_addvarlink(globals, "YieldType_SIMPLE_YIELD", Swig_var_YieldType_SIMPLE_YIELD_get, Swig_var_YieldType_SIMPLE_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_TO_TENDER_DATE", Swig_var_YieldType_YIELD_TO_TENDER_DATE_get, Swig_var_YieldType_YIELD_TO_TENDER_DATE_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_VALUE_OF32NDS", Swig_var_YieldType_YIELD_VALUE_OF32NDS_get, Swig_var_YieldType_YIELD_VALUE_OF32NDS_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_TO_WORST", Swig_var_YieldType_YIELD_TO_WORST_get, Swig_var_YieldType_YIELD_TO_WORST_set);
  SWIG_addvarlink(globals, "YieldType_TAX_EQUIVALENT_YIELD", Swig_var_YieldType_TAX_EQUIVALENT_YIELD_get, Swig_var_YieldType_TAX_EQUIVALENT_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_ANNUAL_YIELD", Swig_var_YieldType_ANNUAL_YIELD_get, Swig_var_YieldType_ANNUAL_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_CLOSING_YIELD_MOST_RECENT_YEAR", Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_get, Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_TO_NEXT_REFUND", Swig_var_YieldType_YIELD_TO_NEXT_REFUND_get, Swig_var_YieldType_YIELD_TO_NEXT_REFUND_set);
  SWIG_addvarlink(globals, "YieldType_AFTER_TAX_YIELD", Swig_var_YieldType_AFTER_TAX_YIELD_get, Swig_var_YieldType_AFTER_TAX_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_AT_ISSUE", Swig_var_YieldType_YIELD_AT_ISSUE_get, Swig_var_YieldType_YIELD_AT_ISSUE_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_TO_AVERAGE_LIFE", Swig_var_YieldType_YIELD_TO_AVERAGE_LIFE_get, Swig_var_YieldType_YIELD_TO_AVERAGE_LIFE_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_TO_AVERAGE_MATURITY", Swig_var_YieldType_YIELD_TO_AVERAGE_MATURITY_get, Swig_var_YieldType_YIELD_TO_AVERAGE_MATURITY_set);
  SWIG_addvarlink(globals, "YieldType_BOOK_YIELD", Swig_var_YieldType_BOOK_YIELD_get, Swig_var_YieldType_BOOK_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_TO_NEXT_CALL", Swig_var_YieldType_YIELD_TO_NEXT_CALL_get, Swig_var_YieldType_YIELD_TO_NEXT_CALL_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_CHANGE_SINCE_CLOSE", Swig_var_YieldType_YIELD_CHANGE_SINCE_CLOSE_get, Swig_var_YieldType_YIELD_CHANGE_SINCE_CLOSE_set);
  SWIG_addvarlink(globals, "YieldType_COMPOUND_YIELD", Swig_var_YieldType_COMPOUND_YIELD_get, Swig_var_YieldType_COMPOUND_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_CURRENT_YIELD", Swig_var_YieldType_CURRENT_YIELD_get, Swig_var_YieldType_CURRENT_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_TRUE_GROSS_YIELD", Swig_var_YieldType_TRUE_GROSS_YIELD_get, Swig_var_YieldType_TRUE_GROSS_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_GVNT_EQUIVALENT_YIELD", Swig_var_YieldType_GVNT_EQUIVALENT_YIELD_get, Swig_var_YieldType_GVNT_EQUIVALENT_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_WITH_INFLATION_ASSUMPTION", Swig_var_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_get, Swig_var_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_set);
  SWIG_addvarlink(globals, "YieldType_INVERSE_FLOATER_BOND_YIELD", Swig_var_YieldType_INVERSE_FLOATER_BOND_YIELD_get, Swig_var_YieldType_INVERSE_FLOATER_BOND_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER", Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_get, Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_set);
  SWIG_addvarlink(globals, "YieldType_MOST_RECENT_CLOSING_YIELD", Swig_var_YieldType_MOST_RECENT_CLOSING_YIELD_get, Swig_var_YieldType_MOST_RECENT_CLOSING_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_CLOSING_YIELD_MOST_RECENT_MONTH", Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_get, Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_set);
  SWIG_addvarlink(globals, "YieldType_CLOSING_YIELD", Swig_var_YieldType_CLOSING_YIELD_get, Swig_var_YieldType_CLOSING_YIELD_set);
  SWIG_addvarlink(globals, "YieldType_YIELD_VALUE_OF132", Swig_var_YieldType_YIELD_VALUE_OF132_get, Swig_var_YieldType_YIELD_VALUE_OF132_set);
  SWIG_addvarlink(globals, "TradedFlatSwitch_NO", Swig_var_TradedFlatSwitch_NO_get, Swig_var_TradedFlatSwitch_NO_set);
  SWIG_addvarlink(globals, "TradedFlatSwitch_YES", Swig_var_TradedFlatSwitch_YES_get, Swig_var_TradedFlatSwitch_YES_set);
  SWIG_addvarlink(globals, "QuoteStatus_REMOVED_FROM_MARKET", Swig_var_QuoteStatus_REMOVED_FROM_MARKET_get, Swig_var_QuoteStatus_REMOVED_FROM_MARKET_set);
  SWIG_addvarlink(globals, "QuoteStatus_CANCEL_FOR_SYMBOL", Swig_var_QuoteStatus_CANCEL_FOR_SYMBOL_get, Swig_var_QuoteStatus_CANCEL_FOR_SYMBOL_set);
  SWIG_addvarlink(globals, "QuoteStatus_PENDING", Swig_var_QuoteStatus_PENDING_get, Swig_var_QuoteStatus_PENDING_set);
  SWIG_addvarlink(globals, "QuoteStatus_QUOTE_NOT_FOUND", Swig_var_QuoteStatus_QUOTE_NOT_FOUND_get, Swig_var_QuoteStatus_QUOTE_NOT_FOUND_set);
  SWIG_addvarlink(globals, "QuoteStatus_QUERY", Swig_var_QuoteStatus_QUERY_get, Swig_var_QuoteStatus_QUERY_set);
  SWIG_addvarlink(globals, "QuoteStatus_EXPIRED", Swig_var_QuoteStatus_EXPIRED_get, Swig_var_QuoteStatus_EXPIRED_set);
  SWIG_addvarlink(globals, "QuoteStatus_REJECTED", Swig_var_QuoteStatus_REJECTED_get, Swig_var_QuoteStatus_REJECTED_set);
  SWIG_addvarlink(globals, "QuoteStatus_CANCELED_ALL", Swig_var_QuoteStatus_CANCELED_ALL_get, Swig_var_QuoteStatus_CANCELED_ALL_set);
  SWIG_addvarlink(globals, "QuoteStatus_CANCELED_FOR_UNDERLYING", Swig_var_QuoteStatus_CANCELED_FOR_UNDERLYING_get, Swig_var_QuoteStatus_CANCELED_FOR_UNDERLYING_set);
  SWIG_addvarlink(globals, "QuoteStatus_CANCELED_FOR_SECURITY_TYPE", Swig_var_QuoteStatus_CANCELED_FOR_SECURITY_TYPE_get, Swig_var_QuoteStatus_CANCELED_FOR_SECURITY_TYPE_set);
  SWIG_addvarlink(globals, "QuoteStatus_ACCEPTED", Swig_var_QuoteStatus_ACCEPTED_get, Swig_var_QuoteStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "QuoteStatus_PASS", Swig_var_QuoteStatus_PASS_get, Swig_var_QuoteStatus_PASS_set);
  SWIG_addvarlink(globals, "QuoteStatus_LOCKED_MARKET_WARNING", Swig_var_QuoteStatus_LOCKED_MARKET_WARNING_get, Swig_var_QuoteStatus_LOCKED_MARKET_WARNING_set);
  SWIG_addvarlink(globals, "QuoteStatus_CROSS_MARKET_WARNING", Swig_var_QuoteStatus_CROSS_MARKET_WARNING_get, Swig_var_QuoteStatus_CROSS_MARKET_WARNING_set);
  SWIG_addvarlink(globals, "QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET", Swig_var_QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET_get, Swig_var_QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET_set);
  SWIG_addvarlink(globals, "QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET", Swig_var_QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET_get, Swig_var_QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET_set);
  SWIG_addvarlink(globals, "QuoteStatus_ACTIVE", Swig_var_QuoteStatus_ACTIVE_get, Swig_var_QuoteStatus_ACTIVE_set);
  SWIG_addvarlink(globals, "QuoteStatus_CANCELED", Swig_var_QuoteStatus_CANCELED_get, Swig_var_QuoteStatus_CANCELED_set);
  SWIG_addvarlink(globals, "QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT", Swig_var_QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT_get, Swig_var_QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT_set);
  SWIG_addvarlink(globals, "QuoteStatus_PENDING_END_TRADE", Swig_var_QuoteStatus_PENDING_END_TRADE_get, Swig_var_QuoteStatus_PENDING_END_TRADE_set);
  SWIG_addvarlink(globals, "QuoteStatus_TOO_LATE_TO_END", Swig_var_QuoteStatus_TOO_LATE_TO_END_get, Swig_var_QuoteStatus_TOO_LATE_TO_END_set);
  SWIG_addvarlink(globals, "QuoteStatus_TRADED", Swig_var_QuoteStatus_TRADED_get, Swig_var_QuoteStatus_TRADED_set);
  SWIG_addvarlink(globals, "QuoteStatus_TRADED_AND_REMOVED", Swig_var_QuoteStatus_TRADED_AND_REMOVED_get, Swig_var_QuoteStatus_TRADED_AND_REMOVED_set);
  SWIG_addvarlink(globals, "QuoteStatus_CONTRACT_TERMINATES", Swig_var_QuoteStatus_CONTRACT_TERMINATES_get, Swig_var_QuoteStatus_CONTRACT_TERMINATES_set);
  SWIG_addvarlink(globals, "PartyIDSource_CHINESE_INVESTOR_ID", Swig_var_PartyIDSource_CHINESE_INVESTOR_ID_get, Swig_var_PartyIDSource_CHINESE_INVESTOR_ID_set);
  SWIG_addvarlink(globals, "PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER", Swig_var_PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER_get, Swig_var_PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER_set);
  SWIG_addvarlink(globals, "PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER", Swig_var_PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER_get, Swig_var_PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER_set);
  SWIG_addvarlink(globals, "PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER", Swig_var_PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER_get, Swig_var_PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER_set);
  SWIG_addvarlink(globals, "PartyIDSource_ISO_COUNTRY_CODE", Swig_var_PartyIDSource_ISO_COUNTRY_CODE_get, Swig_var_PartyIDSource_ISO_COUNTRY_CODE_set);
  SWIG_addvarlink(globals, "PartyIDSource_BIC", Swig_var_PartyIDSource_BIC_get, Swig_var_PartyIDSource_BIC_set);
  SWIG_addvarlink(globals, "PartyIDSource_US_SOCIAL_SECURITY_NUMBER", Swig_var_PartyIDSource_US_SOCIAL_SECURITY_NUMBER_get, Swig_var_PartyIDSource_US_SOCIAL_SECURITY_NUMBER_set);
  SWIG_addvarlink(globals, "PartyIDSource_PROPRIETARY", Swig_var_PartyIDSource_PROPRIETARY_get, Swig_var_PartyIDSource_PROPRIETARY_set);
  SWIG_addvarlink(globals, "PartyIDSource_SETTLEMENT_ENTITY_LOCATION", Swig_var_PartyIDSource_SETTLEMENT_ENTITY_LOCATION_get, Swig_var_PartyIDSource_SETTLEMENT_ENTITY_LOCATION_set);
  SWIG_addvarlink(globals, "PartyIDSource_KOREAN_INVESTOR_ID", Swig_var_PartyIDSource_KOREAN_INVESTOR_ID_get, Swig_var_PartyIDSource_KOREAN_INVESTOR_ID_set);
  SWIG_addvarlink(globals, "PartyIDSource_TAIWANESE_FOREIGN_INVESTOR_ID", Swig_var_PartyIDSource_TAIWANESE_FOREIGN_INVESTOR_ID_get, Swig_var_PartyIDSource_TAIWANESE_FOREIGN_INVESTOR_ID_set);
  SWIG_addvarlink(globals, "PartyIDSource_TAIWANESE_TRADING_ACCT", Swig_var_PartyIDSource_TAIWANESE_TRADING_ACCT_get, Swig_var_PartyIDSource_TAIWANESE_TRADING_ACCT_set);
  SWIG_addvarlink(globals, "PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY", Swig_var_PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY_get, Swig_var_PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY_set);
  SWIG_addvarlink(globals, "PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER", Swig_var_PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER_get, Swig_var_PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER_set);
  SWIG_addvarlink(globals, "PartyIDSource_GENERAL_IDENTIFIER", Swig_var_PartyIDSource_GENERAL_IDENTIFIER_get, Swig_var_PartyIDSource_GENERAL_IDENTIFIER_set);
  SWIG_addvarlink(globals, "PartyIDSource_MIC", Swig_var_PartyIDSource_MIC_get, Swig_var_PartyIDSource_MIC_set);
  SWIG_addvarlink(globals, "PartyIDSource_CSD_PARTICIPANT", Swig_var_PartyIDSource_CSD_PARTICIPANT_get, Swig_var_PartyIDSource_CSD_PARTICIPANT_set);
  SWIG_addvarlink(globals, "PartyIDSource_ISITC_ACRONYM", Swig_var_PartyIDSource_ISITC_ACRONYM_get, Swig_var_PartyIDSource_ISITC_ACRONYM_set);
  SWIG_addvarlink(globals, "PartyIDSource_TAX_ID", Swig_var_PartyIDSource_TAX_ID_get, Swig_var_PartyIDSource_TAX_ID_set);
  SWIG_addvarlink(globals, "PartyIDSource_AUSTRALIAN_COMPANY_NUMBER", Swig_var_PartyIDSource_AUSTRALIAN_COMPANY_NUMBER_get, Swig_var_PartyIDSource_AUSTRALIAN_COMPANY_NUMBER_set);
  SWIG_addvarlink(globals, "PartyIDSource_AUSTRALIAN_REGISTERED_BODY_NUMBER", Swig_var_PartyIDSource_AUSTRALIAN_REGISTERED_BODY_NUMBER_get, Swig_var_PartyIDSource_AUSTRALIAN_REGISTERED_BODY_NUMBER_set);
  SWIG_addvarlink(globals, "PartyIDSource_CFTC_REPORTING_FIRM_IDENTIFIER", Swig_var_PartyIDSource_CFTC_REPORTING_FIRM_IDENTIFIER_get, Swig_var_PartyIDSource_CFTC_REPORTING_FIRM_IDENTIFIER_set);
  SWIG_addvarlink(globals, "PartyIDSource_LEGAL_ENTITY_IDENTIFIER", Swig_var_PartyIDSource_LEGAL_ENTITY_IDENTIFIER_get, Swig_var_PartyIDSource_LEGAL_ENTITY_IDENTIFIER_set);
  SWIG_addvarlink(globals, "PartyIDSource_INTERIM_IDENTIFIER", Swig_var_PartyIDSource_INTERIM_IDENTIFIER_get, Swig_var_PartyIDSource_INTERIM_IDENTIFIER_set);
  SWIG_addvarlink(globals, "PartyIDSource_SHORT_CODE_IDENTIFIER", Swig_var_PartyIDSource_SHORT_CODE_IDENTIFIER_get, Swig_var_PartyIDSource_SHORT_CODE_IDENTIFIER_set);
  SWIG_addvarlink(globals, "PartyIDSource_NATIONAL_ID_NATURAL_PERSON", Swig_var_PartyIDSource_NATIONAL_ID_NATURAL_PERSON_get, Swig_var_PartyIDSource_NATIONAL_ID_NATURAL_PERSON_set);
  SWIG_addvarlink(globals, "PartyIDSource_INDIA_PERMANENT_ACCOUNT_NUMBER", Swig_var_PartyIDSource_INDIA_PERMANENT_ACCOUNT_NUMBER_get, Swig_var_PartyIDSource_INDIA_PERMANENT_ACCOUNT_NUMBER_set);
  SWIG_addvarlink(globals, "PartyIDSource_FDID", Swig_var_PartyIDSource_FDID_get, Swig_var_PartyIDSource_FDID_set);
  SWIG_addvarlink(globals, "PartyIDSource_SPSAID", Swig_var_PartyIDSource_SPSAID_get, Swig_var_PartyIDSource_SPSAID_set);
  SWIG_addvarlink(globals, "PartyIDSource_MASTER_SPSAID", Swig_var_PartyIDSource_MASTER_SPSAID_get, Swig_var_PartyIDSource_MASTER_SPSAID_set);
  SWIG_addvarlink(globals, "PartyRole_CORRESPONDANT_CLEARING_FIRM", Swig_var_PartyRole_CORRESPONDANT_CLEARING_FIRM_get, Swig_var_PartyRole_CORRESPONDANT_CLEARING_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_CLIENT_ID", Swig_var_PartyRole_CLIENT_ID_get, Swig_var_PartyRole_CLIENT_ID_set);
  SWIG_addvarlink(globals, "PartyRole_UNDERLYING_CONTRA_FIRM", Swig_var_PartyRole_UNDERLYING_CONTRA_FIRM_get, Swig_var_PartyRole_UNDERLYING_CONTRA_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_SPONSORING_FIRM", Swig_var_PartyRole_SPONSORING_FIRM_get, Swig_var_PartyRole_SPONSORING_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_CONTRA_CLEARING_FIRM", Swig_var_PartyRole_CONTRA_CLEARING_FIRM_get, Swig_var_PartyRole_CONTRA_CLEARING_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_CONTRA_FIRM", Swig_var_PartyRole_CONTRA_FIRM_get, Swig_var_PartyRole_CONTRA_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_EXECUTING_SYSTEM", Swig_var_PartyRole_EXECUTING_SYSTEM_get, Swig_var_PartyRole_EXECUTING_SYSTEM_set);
  SWIG_addvarlink(globals, "PartyRole_ENTERING_FIRM", Swig_var_PartyRole_ENTERING_FIRM_get, Swig_var_PartyRole_ENTERING_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_EXECUTING_FIRM", Swig_var_PartyRole_EXECUTING_FIRM_get, Swig_var_PartyRole_EXECUTING_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_BROKER_OF_CREDIT", Swig_var_PartyRole_BROKER_OF_CREDIT_get, Swig_var_PartyRole_BROKER_OF_CREDIT_set);
  SWIG_addvarlink(globals, "PartyRole_INVESTOR_ID", Swig_var_PartyRole_INVESTOR_ID_get, Swig_var_PartyRole_INVESTOR_ID_set);
  SWIG_addvarlink(globals, "PartyRole_INTRODUCING_FIRM", Swig_var_PartyRole_INTRODUCING_FIRM_get, Swig_var_PartyRole_INTRODUCING_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_GIVEUP_CLEARING_FIRM", Swig_var_PartyRole_GIVEUP_CLEARING_FIRM_get, Swig_var_PartyRole_GIVEUP_CLEARING_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_LOCATE", Swig_var_PartyRole_LOCATE_get, Swig_var_PartyRole_LOCATE_set);
  SWIG_addvarlink(globals, "PartyRole_FUND_MANAGER_CLIENT_ID", Swig_var_PartyRole_FUND_MANAGER_CLIENT_ID_get, Swig_var_PartyRole_FUND_MANAGER_CLIENT_ID_set);
  SWIG_addvarlink(globals, "PartyRole_SETTLEMENT_LOCATION", Swig_var_PartyRole_SETTLEMENT_LOCATION_get, Swig_var_PartyRole_SETTLEMENT_LOCATION_set);
  SWIG_addvarlink(globals, "PartyRole_ORDER_ORIGINATION_TRADER", Swig_var_PartyRole_ORDER_ORIGINATION_TRADER_get, Swig_var_PartyRole_ORDER_ORIGINATION_TRADER_set);
  SWIG_addvarlink(globals, "PartyRole_EXECUTING_TRADER", Swig_var_PartyRole_EXECUTING_TRADER_get, Swig_var_PartyRole_EXECUTING_TRADER_set);
  SWIG_addvarlink(globals, "PartyRole_ORDER_ORIGINATION_FIRM", Swig_var_PartyRole_ORDER_ORIGINATION_FIRM_get, Swig_var_PartyRole_ORDER_ORIGINATION_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_CLEARING_FIRM", Swig_var_PartyRole_CLEARING_FIRM_get, Swig_var_PartyRole_CLEARING_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_CLEARING_ORGANIZATION", Swig_var_PartyRole_CLEARING_ORGANIZATION_get, Swig_var_PartyRole_CLEARING_ORGANIZATION_set);
  SWIG_addvarlink(globals, "PartyRole_EXCHANGE", Swig_var_PartyRole_EXCHANGE_get, Swig_var_PartyRole_EXCHANGE_set);
  SWIG_addvarlink(globals, "PartyRole_CUSTOMER_ACCOUNT", Swig_var_PartyRole_CUSTOMER_ACCOUNT_get, Swig_var_PartyRole_CUSTOMER_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION", Swig_var_PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION_get, Swig_var_PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION_set);
  SWIG_addvarlink(globals, "PartyRole_CORRESPONDENT_BROKER", Swig_var_PartyRole_CORRESPONDENT_BROKER_get, Swig_var_PartyRole_CORRESPONDENT_BROKER_set);
  SWIG_addvarlink(globals, "PartyRole_BUYER", Swig_var_PartyRole_BUYER_get, Swig_var_PartyRole_BUYER_set);
  SWIG_addvarlink(globals, "PartyRole_CUSTODIAN", Swig_var_PartyRole_CUSTODIAN_get, Swig_var_PartyRole_CUSTODIAN_set);
  SWIG_addvarlink(globals, "PartyRole_INTERMEDIARY", Swig_var_PartyRole_INTERMEDIARY_get, Swig_var_PartyRole_INTERMEDIARY_set);
  SWIG_addvarlink(globals, "PartyRole_AGENT", Swig_var_PartyRole_AGENT_get, Swig_var_PartyRole_AGENT_set);
  SWIG_addvarlink(globals, "PartyRole_SUB_CUSTODIAN", Swig_var_PartyRole_SUB_CUSTODIAN_get, Swig_var_PartyRole_SUB_CUSTODIAN_set);
  SWIG_addvarlink(globals, "PartyRole_BENEFICIARY", Swig_var_PartyRole_BENEFICIARY_get, Swig_var_PartyRole_BENEFICIARY_set);
  SWIG_addvarlink(globals, "PartyRole_INTERESTED_PARTY", Swig_var_PartyRole_INTERESTED_PARTY_get, Swig_var_PartyRole_INTERESTED_PARTY_set);
  SWIG_addvarlink(globals, "PartyRole_REGULATORY_BODY", Swig_var_PartyRole_REGULATORY_BODY_get, Swig_var_PartyRole_REGULATORY_BODY_set);
  SWIG_addvarlink(globals, "PartyRole_LIQUIDITY_PROVIDER", Swig_var_PartyRole_LIQUIDITY_PROVIDER_get, Swig_var_PartyRole_LIQUIDITY_PROVIDER_set);
  SWIG_addvarlink(globals, "PartyRole_ENTERING_TRADER", Swig_var_PartyRole_ENTERING_TRADER_get, Swig_var_PartyRole_ENTERING_TRADER_set);
  SWIG_addvarlink(globals, "PartyRole_CONTRA_TRADER", Swig_var_PartyRole_CONTRA_TRADER_get, Swig_var_PartyRole_CONTRA_TRADER_set);
  SWIG_addvarlink(globals, "PartyRole_POSITION_ACCOUNT", Swig_var_PartyRole_POSITION_ACCOUNT_get, Swig_var_PartyRole_POSITION_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_CONTRA_INVESTOR_ID", Swig_var_PartyRole_CONTRA_INVESTOR_ID_get, Swig_var_PartyRole_CONTRA_INVESTOR_ID_set);
  SWIG_addvarlink(globals, "PartyRole_TRANSFER_TO_FIRM", Swig_var_PartyRole_TRANSFER_TO_FIRM_get, Swig_var_PartyRole_TRANSFER_TO_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_CONTRA_POSITION_ACCOUNT", Swig_var_PartyRole_CONTRA_POSITION_ACCOUNT_get, Swig_var_PartyRole_CONTRA_POSITION_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_CONTRA_EXCHANGE", Swig_var_PartyRole_CONTRA_EXCHANGE_get, Swig_var_PartyRole_CONTRA_EXCHANGE_set);
  SWIG_addvarlink(globals, "PartyRole_INTERNAL_CARRY_ACCOUNT", Swig_var_PartyRole_INTERNAL_CARRY_ACCOUNT_get, Swig_var_PartyRole_INTERNAL_CARRY_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_ORDER_ENTRY_OPERATOR_ID", Swig_var_PartyRole_ORDER_ENTRY_OPERATOR_ID_get, Swig_var_PartyRole_ORDER_ENTRY_OPERATOR_ID_set);
  SWIG_addvarlink(globals, "PartyRole_SECONDARY_ACCOUNT_NUMBER", Swig_var_PartyRole_SECONDARY_ACCOUNT_NUMBER_get, Swig_var_PartyRole_SECONDARY_ACCOUNT_NUMBER_set);
  SWIG_addvarlink(globals, "PartyRole_FOREIGN_FIRM", Swig_var_PartyRole_FOREIGN_FIRM_get, Swig_var_PartyRole_FOREIGN_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_THIRD_PARTY_ALLOCATION_FIRM", Swig_var_PartyRole_THIRD_PARTY_ALLOCATION_FIRM_get, Swig_var_PartyRole_THIRD_PARTY_ALLOCATION_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_CLAIMING_ACCOUNT", Swig_var_PartyRole_CLAIMING_ACCOUNT_get, Swig_var_PartyRole_CLAIMING_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_ASSET_MANAGER", Swig_var_PartyRole_ASSET_MANAGER_get, Swig_var_PartyRole_ASSET_MANAGER_set);
  SWIG_addvarlink(globals, "PartyRole_PLEDGOR_ACCOUNT", Swig_var_PartyRole_PLEDGOR_ACCOUNT_get, Swig_var_PartyRole_PLEDGOR_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_PLEDGEE_ACCOUNT", Swig_var_PartyRole_PLEDGEE_ACCOUNT_get, Swig_var_PartyRole_PLEDGEE_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT", Swig_var_PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT_get, Swig_var_PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_TRADER_MNEMONIC", Swig_var_PartyRole_TRADER_MNEMONIC_get, Swig_var_PartyRole_TRADER_MNEMONIC_set);
  SWIG_addvarlink(globals, "PartyRole_SENDER_LOCATION", Swig_var_PartyRole_SENDER_LOCATION_get, Swig_var_PartyRole_SENDER_LOCATION_set);
  SWIG_addvarlink(globals, "PartyRole_SESSION_ID", Swig_var_PartyRole_SESSION_ID_get, Swig_var_PartyRole_SESSION_ID_set);
  SWIG_addvarlink(globals, "PartyRole_ACCEPTABLE_COUNTERPARTY", Swig_var_PartyRole_ACCEPTABLE_COUNTERPARTY_get, Swig_var_PartyRole_ACCEPTABLE_COUNTERPARTY_set);
  SWIG_addvarlink(globals, "PartyRole_UNACCEPTABLE_COUNTERPARTY", Swig_var_PartyRole_UNACCEPTABLE_COUNTERPARTY_get, Swig_var_PartyRole_UNACCEPTABLE_COUNTERPARTY_set);
  SWIG_addvarlink(globals, "PartyRole_ENTERING_UNIT", Swig_var_PartyRole_ENTERING_UNIT_get, Swig_var_PartyRole_ENTERING_UNIT_set);
  SWIG_addvarlink(globals, "PartyRole_EXECUTING_UNIT", Swig_var_PartyRole_EXECUTING_UNIT_get, Swig_var_PartyRole_EXECUTING_UNIT_set);
  SWIG_addvarlink(globals, "PartyRole_INTRODUCING_BROKER", Swig_var_PartyRole_INTRODUCING_BROKER_get, Swig_var_PartyRole_INTRODUCING_BROKER_set);
  SWIG_addvarlink(globals, "PartyRole_QUOTE_ORIGINATOR", Swig_var_PartyRole_QUOTE_ORIGINATOR_get, Swig_var_PartyRole_QUOTE_ORIGINATOR_set);
  SWIG_addvarlink(globals, "PartyRole_REPORT_ORIGINATOR", Swig_var_PartyRole_REPORT_ORIGINATOR_get, Swig_var_PartyRole_REPORT_ORIGINATOR_set);
  SWIG_addvarlink(globals, "PartyRole_SYSTEMATIC_INTERNALISER", Swig_var_PartyRole_SYSTEMATIC_INTERNALISER_get, Swig_var_PartyRole_SYSTEMATIC_INTERNALISER_set);
  SWIG_addvarlink(globals, "PartyRole_MULTILATERAL_TRADING_FACILITY", Swig_var_PartyRole_MULTILATERAL_TRADING_FACILITY_get, Swig_var_PartyRole_MULTILATERAL_TRADING_FACILITY_set);
  SWIG_addvarlink(globals, "PartyRole_REGULATED_MARKET", Swig_var_PartyRole_REGULATED_MARKET_get, Swig_var_PartyRole_REGULATED_MARKET_set);
  SWIG_addvarlink(globals, "PartyRole_MARKET_MAKER", Swig_var_PartyRole_MARKET_MAKER_get, Swig_var_PartyRole_MARKET_MAKER_set);
  SWIG_addvarlink(globals, "PartyRole_INVESTMENT_FIRM", Swig_var_PartyRole_INVESTMENT_FIRM_get, Swig_var_PartyRole_INVESTMENT_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_HOST_COMPETENT_AUTHORITY", Swig_var_PartyRole_HOST_COMPETENT_AUTHORITY_get, Swig_var_PartyRole_HOST_COMPETENT_AUTHORITY_set);
  SWIG_addvarlink(globals, "PartyRole_HOME_COMPETENT_AUTHORITY", Swig_var_PartyRole_HOME_COMPETENT_AUTHORITY_get, Swig_var_PartyRole_HOME_COMPETENT_AUTHORITY_set);
  SWIG_addvarlink(globals, "PartyRole_COMPETENT_AUTHORITY_LIQUIDITY", Swig_var_PartyRole_COMPETENT_AUTHORITY_LIQUIDITY_get, Swig_var_PartyRole_COMPETENT_AUTHORITY_LIQUIDITY_set);
  SWIG_addvarlink(globals, "PartyRole_COMPETENT_AUTHORITY_TRANSACTION_VENUE", Swig_var_PartyRole_COMPETENT_AUTHORITY_TRANSACTION_VENUE_get, Swig_var_PartyRole_COMPETENT_AUTHORITY_TRANSACTION_VENUE_set);
  SWIG_addvarlink(globals, "PartyRole_REPORTING_INTERMEDIARY", Swig_var_PartyRole_REPORTING_INTERMEDIARY_get, Swig_var_PartyRole_REPORTING_INTERMEDIARY_set);
  SWIG_addvarlink(globals, "PartyRole_EXECUTION_VENUE", Swig_var_PartyRole_EXECUTION_VENUE_get, Swig_var_PartyRole_EXECUTION_VENUE_set);
  SWIG_addvarlink(globals, "PartyRole_MARKET_DATA_ENTRY_ORIGINATOR", Swig_var_PartyRole_MARKET_DATA_ENTRY_ORIGINATOR_get, Swig_var_PartyRole_MARKET_DATA_ENTRY_ORIGINATOR_set);
  SWIG_addvarlink(globals, "PartyRole_LOCATION_ID", Swig_var_PartyRole_LOCATION_ID_get, Swig_var_PartyRole_LOCATION_ID_set);
  SWIG_addvarlink(globals, "PartyRole_DESK_ID", Swig_var_PartyRole_DESK_ID_get, Swig_var_PartyRole_DESK_ID_set);
  SWIG_addvarlink(globals, "PartyRole_MARKET_DATA_MARKET", Swig_var_PartyRole_MARKET_DATA_MARKET_get, Swig_var_PartyRole_MARKET_DATA_MARKET_set);
  SWIG_addvarlink(globals, "PartyRole_ALLOCATION_ENTITY", Swig_var_PartyRole_ALLOCATION_ENTITY_get, Swig_var_PartyRole_ALLOCATION_ENTITY_set);
  SWIG_addvarlink(globals, "PartyRole_PRIME_BROKER", Swig_var_PartyRole_PRIME_BROKER_get, Swig_var_PartyRole_PRIME_BROKER_set);
  SWIG_addvarlink(globals, "PartyRole_STEP_OUT_FIRM", Swig_var_PartyRole_STEP_OUT_FIRM_get, Swig_var_PartyRole_STEP_OUT_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_BROKER_CLEARING_ID", Swig_var_PartyRole_BROKER_CLEARING_ID_get, Swig_var_PartyRole_BROKER_CLEARING_ID_set);
  SWIG_addvarlink(globals, "PartyRole_GIVEUP_CLEARING_FIRM_DEPR", Swig_var_PartyRole_GIVEUP_CLEARING_FIRM_DEPR_get, Swig_var_PartyRole_GIVEUP_CLEARING_FIRM_DEPR_set);
  SWIG_addvarlink(globals, "PartyRole_CENTRAL_REGISTRATION_DEPOSITORY", Swig_var_PartyRole_CENTRAL_REGISTRATION_DEPOSITORY_get, Swig_var_PartyRole_CENTRAL_REGISTRATION_DEPOSITORY_set);
  SWIG_addvarlink(globals, "PartyRole_CLEARING_ACCOUNT", Swig_var_PartyRole_CLEARING_ACCOUNT_get, Swig_var_PartyRole_CLEARING_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY", Swig_var_PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY_get, Swig_var_PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY_set);
  SWIG_addvarlink(globals, "PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY", Swig_var_PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY_get, Swig_var_PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY_set);
  SWIG_addvarlink(globals, "PartyRole_CLS_MEMBER_BANK", Swig_var_PartyRole_CLS_MEMBER_BANK_get, Swig_var_PartyRole_CLS_MEMBER_BANK_set);
  SWIG_addvarlink(globals, "PartyRole_IN_CONCERT_GROUP", Swig_var_PartyRole_IN_CONCERT_GROUP_get, Swig_var_PartyRole_IN_CONCERT_GROUP_set);
  SWIG_addvarlink(globals, "PartyRole_IN_CONCERT_CONTROLLING_ENTITY", Swig_var_PartyRole_IN_CONCERT_CONTROLLING_ENTITY_get, Swig_var_PartyRole_IN_CONCERT_CONTROLLING_ENTITY_set);
  SWIG_addvarlink(globals, "PartyRole_LARGE_POSITIONS_REPORTING_ACCOUNT", Swig_var_PartyRole_LARGE_POSITIONS_REPORTING_ACCOUNT_get, Swig_var_PartyRole_LARGE_POSITIONS_REPORTING_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_SETTLEMENT_FIRM", Swig_var_PartyRole_SETTLEMENT_FIRM_get, Swig_var_PartyRole_SETTLEMENT_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_SETTLEMENT_ACCOUNT", Swig_var_PartyRole_SETTLEMENT_ACCOUNT_get, Swig_var_PartyRole_SETTLEMENT_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_REPORTING_MARKET_CENTER", Swig_var_PartyRole_REPORTING_MARKET_CENTER_get, Swig_var_PartyRole_REPORTING_MARKET_CENTER_set);
  SWIG_addvarlink(globals, "PartyRole_RELATED_REPORTING_MARKET_CENTER", Swig_var_PartyRole_RELATED_REPORTING_MARKET_CENTER_get, Swig_var_PartyRole_RELATED_REPORTING_MARKET_CENTER_set);
  SWIG_addvarlink(globals, "PartyRole_AWAY_MARKET", Swig_var_PartyRole_AWAY_MARKET_get, Swig_var_PartyRole_AWAY_MARKET_set);
  SWIG_addvarlink(globals, "PartyRole_GIVEUP_TRADING_FIRM", Swig_var_PartyRole_GIVEUP_TRADING_FIRM_get, Swig_var_PartyRole_GIVEUP_TRADING_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_TAKEUP_TRADING_FIRM", Swig_var_PartyRole_TAKEUP_TRADING_FIRM_get, Swig_var_PartyRole_TAKEUP_TRADING_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_TAKEUP_CLEARING_FIRM", Swig_var_PartyRole_TAKEUP_CLEARING_FIRM_get, Swig_var_PartyRole_TAKEUP_CLEARING_FIRM_set);
  SWIG_addvarlink(globals, "PartyRole_ORIGINATING_MARKET", Swig_var_PartyRole_ORIGINATING_MARKET_get, Swig_var_PartyRole_ORIGINATING_MARKET_set);
  SWIG_addvarlink(globals, "PartyRole_MARGIN_ACCOUNT", Swig_var_PartyRole_MARGIN_ACCOUNT_get, Swig_var_PartyRole_MARGIN_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_COLLATERAL_ASSET_ACCOUNT", Swig_var_PartyRole_COLLATERAL_ASSET_ACCOUNT_get, Swig_var_PartyRole_COLLATERAL_ASSET_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_DATA_REPOSITORY", Swig_var_PartyRole_DATA_REPOSITORY_get, Swig_var_PartyRole_DATA_REPOSITORY_set);
  SWIG_addvarlink(globals, "PartyRole_CALCULATION_AGENT", Swig_var_PartyRole_CALCULATION_AGENT_get, Swig_var_PartyRole_CALCULATION_AGENT_set);
  SWIG_addvarlink(globals, "PartyRole_EXERCISE_NOTICE_SENDER", Swig_var_PartyRole_EXERCISE_NOTICE_SENDER_get, Swig_var_PartyRole_EXERCISE_NOTICE_SENDER_set);
  SWIG_addvarlink(globals, "PartyRole_EXERCISE_NOTICE_RECEIVER", Swig_var_PartyRole_EXERCISE_NOTICE_RECEIVER_get, Swig_var_PartyRole_EXERCISE_NOTICE_RECEIVER_set);
  SWIG_addvarlink(globals, "PartyRole_RATE_REFERENCE_BANK", Swig_var_PartyRole_RATE_REFERENCE_BANK_get, Swig_var_PartyRole_RATE_REFERENCE_BANK_set);
  SWIG_addvarlink(globals, "PartyRole_CORRESPONDENT", Swig_var_PartyRole_CORRESPONDENT_get, Swig_var_PartyRole_CORRESPONDENT_set);
  SWIG_addvarlink(globals, "PartyRole_BENEFICIARY_BANK", Swig_var_PartyRole_BENEFICIARY_BANK_get, Swig_var_PartyRole_BENEFICIARY_BANK_set);
  SWIG_addvarlink(globals, "PartyRole_BORROWER", Swig_var_PartyRole_BORROWER_get, Swig_var_PartyRole_BORROWER_set);
  SWIG_addvarlink(globals, "PartyRole_PRIMARY_OBLIGATOR", Swig_var_PartyRole_PRIMARY_OBLIGATOR_get, Swig_var_PartyRole_PRIMARY_OBLIGATOR_set);
  SWIG_addvarlink(globals, "PartyRole_GUARANTOR", Swig_var_PartyRole_GUARANTOR_get, Swig_var_PartyRole_GUARANTOR_set);
  SWIG_addvarlink(globals, "PartyRole_EXCLUDED_REFERENCE_ENTITY", Swig_var_PartyRole_EXCLUDED_REFERENCE_ENTITY_get, Swig_var_PartyRole_EXCLUDED_REFERENCE_ENTITY_set);
  SWIG_addvarlink(globals, "PartyRole_DETERMINING_PARTY", Swig_var_PartyRole_DETERMINING_PARTY_get, Swig_var_PartyRole_DETERMINING_PARTY_set);
  SWIG_addvarlink(globals, "PartyRole_HEDGING_PARTY", Swig_var_PartyRole_HEDGING_PARTY_get, Swig_var_PartyRole_HEDGING_PARTY_set);
  SWIG_addvarlink(globals, "PartyRole_REPORTING_ENTITY", Swig_var_PartyRole_REPORTING_ENTITY_get, Swig_var_PartyRole_REPORTING_ENTITY_set);
  SWIG_addvarlink(globals, "PartyRole_SALES_PERSON", Swig_var_PartyRole_SALES_PERSON_get, Swig_var_PartyRole_SALES_PERSON_set);
  SWIG_addvarlink(globals, "PartyRole_OPERATOR", Swig_var_PartyRole_OPERATOR_get, Swig_var_PartyRole_OPERATOR_set);
  SWIG_addvarlink(globals, "PartyRole_CSD", Swig_var_PartyRole_CSD_get, Swig_var_PartyRole_CSD_set);
  SWIG_addvarlink(globals, "PartyRole_ICSD", Swig_var_PartyRole_ICSD_get, Swig_var_PartyRole_ICSD_set);
  SWIG_addvarlink(globals, "PartyRole_TRADING_SUB_ACCOUNT", Swig_var_PartyRole_TRADING_SUB_ACCOUNT_get, Swig_var_PartyRole_TRADING_SUB_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_INVESTMENT_DECISION_MAKER", Swig_var_PartyRole_INVESTMENT_DECISION_MAKER_get, Swig_var_PartyRole_INVESTMENT_DECISION_MAKER_set);
  SWIG_addvarlink(globals, "PartyRole_PUBLISHING_INTERMEDIARY", Swig_var_PartyRole_PUBLISHING_INTERMEDIARY_get, Swig_var_PartyRole_PUBLISHING_INTERMEDIARY_set);
  SWIG_addvarlink(globals, "PartyRole_CSD_PARTICIPANT", Swig_var_PartyRole_CSD_PARTICIPANT_get, Swig_var_PartyRole_CSD_PARTICIPANT_set);
  SWIG_addvarlink(globals, "PartyRole_ISSUER", Swig_var_PartyRole_ISSUER_get, Swig_var_PartyRole_ISSUER_set);
  SWIG_addvarlink(globals, "PartyRole_CONTRA_CUSTOMER_ACCOUNT", Swig_var_PartyRole_CONTRA_CUSTOMER_ACCOUNT_get, Swig_var_PartyRole_CONTRA_CUSTOMER_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartyRole_CONTRA_INVESTMENT_DECISION_MAKER", Swig_var_PartyRole_CONTRA_INVESTMENT_DECISION_MAKER_get, Swig_var_PartyRole_CONTRA_INVESTMENT_DECISION_MAKER_set);
  SWIG_addvarlink(globals, "Product_LOAN", Swig_var_Product_LOAN_get, Swig_var_Product_LOAN_set);
  SWIG_addvarlink(globals, "Product_OTHER", Swig_var_Product_OTHER_get, Swig_var_Product_OTHER_set);
  SWIG_addvarlink(globals, "Product_MUNICIPAL", Swig_var_Product_MUNICIPAL_get, Swig_var_Product_MUNICIPAL_set);
  SWIG_addvarlink(globals, "Product_AGENCY", Swig_var_Product_AGENCY_get, Swig_var_Product_AGENCY_set);
  SWIG_addvarlink(globals, "Product_CORPORATE", Swig_var_Product_CORPORATE_get, Swig_var_Product_CORPORATE_set);
  SWIG_addvarlink(globals, "Product_CURRENCY", Swig_var_Product_CURRENCY_get, Swig_var_Product_CURRENCY_set);
  SWIG_addvarlink(globals, "Product_COMMODITY", Swig_var_Product_COMMODITY_get, Swig_var_Product_COMMODITY_set);
  SWIG_addvarlink(globals, "Product_GOVERNMENT", Swig_var_Product_GOVERNMENT_get, Swig_var_Product_GOVERNMENT_set);
  SWIG_addvarlink(globals, "Product_MORTGAGE", Swig_var_Product_MORTGAGE_get, Swig_var_Product_MORTGAGE_set);
  SWIG_addvarlink(globals, "Product_INDEX", Swig_var_Product_INDEX_get, Swig_var_Product_INDEX_set);
  SWIG_addvarlink(globals, "Product_MONEYMARKET", Swig_var_Product_MONEYMARKET_get, Swig_var_Product_MONEYMARKET_set);
  SWIG_addvarlink(globals, "Product_EQUITY", Swig_var_Product_EQUITY_get, Swig_var_Product_EQUITY_set);
  SWIG_addvarlink(globals, "Product_FINANCING", Swig_var_Product_FINANCING_get, Swig_var_Product_FINANCING_set);
  SWIG_addvarlink(globals, "QuantityType_CONTRACTS", Swig_var_QuantityType_CONTRACTS_get, Swig_var_QuantityType_CONTRACTS_set);
  SWIG_addvarlink(globals, "QuantityType_OTHER", Swig_var_QuantityType_OTHER_get, Swig_var_QuantityType_OTHER_set);
  SWIG_addvarlink(globals, "QuantityType_CURRENCY", Swig_var_QuantityType_CURRENCY_get, Swig_var_QuantityType_CURRENCY_set);
  SWIG_addvarlink(globals, "QuantityType_ORIGINALFACE", Swig_var_QuantityType_ORIGINALFACE_get, Swig_var_QuantityType_ORIGINALFACE_set);
  SWIG_addvarlink(globals, "QuantityType_CURRENTFACE", Swig_var_QuantityType_CURRENTFACE_get, Swig_var_QuantityType_CURRENTFACE_set);
  SWIG_addvarlink(globals, "QuantityType_BONDS", Swig_var_QuantityType_BONDS_get, Swig_var_QuantityType_BONDS_set);
  SWIG_addvarlink(globals, "QuantityType_SHARES", Swig_var_QuantityType_SHARES_get, Swig_var_QuantityType_SHARES_set);
  SWIG_addvarlink(globals, "QuantityType_PAR", Swig_var_QuantityType_PAR_get, Swig_var_QuantityType_PAR_set);
  SWIG_addvarlink(globals, "RoundingDirection_ROUND_TO_NEAREST", Swig_var_RoundingDirection_ROUND_TO_NEAREST_get, Swig_var_RoundingDirection_ROUND_TO_NEAREST_set);
  SWIG_addvarlink(globals, "RoundingDirection_ROUND_DOWN", Swig_var_RoundingDirection_ROUND_DOWN_get, Swig_var_RoundingDirection_ROUND_DOWN_set);
  SWIG_addvarlink(globals, "RoundingDirection_ROUND_UP", Swig_var_RoundingDirection_ROUND_UP_get, Swig_var_RoundingDirection_ROUND_UP_set);
  SWIG_addvarlink(globals, "DistribPaymentMethod_CREST", Swig_var_DistribPaymentMethod_CREST_get, Swig_var_DistribPaymentMethod_CREST_set);
  SWIG_addvarlink(globals, "DistribPaymentMethod_NSCC", Swig_var_DistribPaymentMethod_NSCC_get, Swig_var_DistribPaymentMethod_NSCC_set);
  SWIG_addvarlink(globals, "DistribPaymentMethod_EUROCLEAR", Swig_var_DistribPaymentMethod_EUROCLEAR_get, Swig_var_DistribPaymentMethod_EUROCLEAR_set);
  SWIG_addvarlink(globals, "DistribPaymentMethod_CLEARSTREAM", Swig_var_DistribPaymentMethod_CLEARSTREAM_get, Swig_var_DistribPaymentMethod_CLEARSTREAM_set);
  SWIG_addvarlink(globals, "DistribPaymentMethod_CHEQUE", Swig_var_DistribPaymentMethod_CHEQUE_get, Swig_var_DistribPaymentMethod_CHEQUE_set);
  SWIG_addvarlink(globals, "DistribPaymentMethod_TELEGRAPHIC_TRANSFER", Swig_var_DistribPaymentMethod_TELEGRAPHIC_TRANSFER_get, Swig_var_DistribPaymentMethod_TELEGRAPHIC_TRANSFER_set);
  SWIG_addvarlink(globals, "DistribPaymentMethod_FED_WIRE", Swig_var_DistribPaymentMethod_FED_WIRE_get, Swig_var_DistribPaymentMethod_FED_WIRE_set);
  SWIG_addvarlink(globals, "DistribPaymentMethod_DIRECT_CREDIT", Swig_var_DistribPaymentMethod_DIRECT_CREDIT_get, Swig_var_DistribPaymentMethod_DIRECT_CREDIT_set);
  SWIG_addvarlink(globals, "DistribPaymentMethod_ACH_CREDIT", Swig_var_DistribPaymentMethod_ACH_CREDIT_get, Swig_var_DistribPaymentMethod_ACH_CREDIT_set);
  SWIG_addvarlink(globals, "DistribPaymentMethod_BPAY", Swig_var_DistribPaymentMethod_BPAY_get, Swig_var_DistribPaymentMethod_BPAY_set);
  SWIG_addvarlink(globals, "DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS", Swig_var_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS_get, Swig_var_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS_set);
  SWIG_addvarlink(globals, "DistribPaymentMethod_REINVEST_IN_FUND", Swig_var_DistribPaymentMethod_REINVEST_IN_FUND_get, Swig_var_DistribPaymentMethod_REINVEST_IN_FUND_set);
  SWIG_addvarlink(globals, "DistribPaymentMethod_OTHER", Swig_var_DistribPaymentMethod_OTHER_get, Swig_var_DistribPaymentMethod_OTHER_set);
  SWIG_addvarlink(globals, "CancellationRights_NO_WAIVER_AGREEMENT", Swig_var_CancellationRights_NO_WAIVER_AGREEMENT_get, Swig_var_CancellationRights_NO_WAIVER_AGREEMENT_set);
  SWIG_addvarlink(globals, "CancellationRights_NO_EXECUTION_ONLY", Swig_var_CancellationRights_NO_EXECUTION_ONLY_get, Swig_var_CancellationRights_NO_EXECUTION_ONLY_set);
  SWIG_addvarlink(globals, "CancellationRights_YES", Swig_var_CancellationRights_YES_get, Swig_var_CancellationRights_YES_set);
  SWIG_addvarlink(globals, "CancellationRights_NO_INSTITUTIONAL", Swig_var_CancellationRights_NO_INSTITUTIONAL_get, Swig_var_CancellationRights_NO_INSTITUTIONAL_set);
  SWIG_addvarlink(globals, "MoneyLaunderingStatus_EXEMPT_AUTHORISED", Swig_var_MoneyLaunderingStatus_EXEMPT_AUTHORISED_get, Swig_var_MoneyLaunderingStatus_EXEMPT_AUTHORISED_set);
  SWIG_addvarlink(globals, "MoneyLaunderingStatus_EXEMPT_MONEY_TYPE", Swig_var_MoneyLaunderingStatus_EXEMPT_MONEY_TYPE_get, Swig_var_MoneyLaunderingStatus_EXEMPT_MONEY_TYPE_set);
  SWIG_addvarlink(globals, "MoneyLaunderingStatus_EXEMPT_BELOW_LIMIT", Swig_var_MoneyLaunderingStatus_EXEMPT_BELOW_LIMIT_get, Swig_var_MoneyLaunderingStatus_EXEMPT_BELOW_LIMIT_set);
  SWIG_addvarlink(globals, "MoneyLaunderingStatus_PASSED", Swig_var_MoneyLaunderingStatus_PASSED_get, Swig_var_MoneyLaunderingStatus_PASSED_set);
  SWIG_addvarlink(globals, "MoneyLaunderingStatus_NOT_CHECKED", Swig_var_MoneyLaunderingStatus_NOT_CHECKED_get, Swig_var_MoneyLaunderingStatus_NOT_CHECKED_set);
  SWIG_addvarlink(globals, "ExecPriceType_SINGLE_PRICE", Swig_var_ExecPriceType_SINGLE_PRICE_get, Swig_var_ExecPriceType_SINGLE_PRICE_set);
  SWIG_addvarlink(globals, "ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT", Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT_get, Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT_set);
  SWIG_addvarlink(globals, "ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT", Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT_get, Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT_set);
  SWIG_addvarlink(globals, "ExecPriceType_OFFER_PRICE", Swig_var_ExecPriceType_OFFER_PRICE_get, Swig_var_ExecPriceType_OFFER_PRICE_set);
  SWIG_addvarlink(globals, "ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT", Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT_get, Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT_set);
  SWIG_addvarlink(globals, "ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT", Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT_get, Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT_set);
  SWIG_addvarlink(globals, "ExecPriceType_CREATION_PRICE", Swig_var_ExecPriceType_CREATION_PRICE_get, Swig_var_ExecPriceType_CREATION_PRICE_set);
  SWIG_addvarlink(globals, "ExecPriceType_BID_PRICE", Swig_var_ExecPriceType_BID_PRICE_get, Swig_var_ExecPriceType_BID_PRICE_set);
  SWIG_addvarlink(globals, "TradeReportTransType_NEW", Swig_var_TradeReportTransType_NEW_get, Swig_var_TradeReportTransType_NEW_set);
  SWIG_addvarlink(globals, "TradeReportTransType_REPLACE", Swig_var_TradeReportTransType_REPLACE_get, Swig_var_TradeReportTransType_REPLACE_set);
  SWIG_addvarlink(globals, "TradeReportTransType_CANCEL", Swig_var_TradeReportTransType_CANCEL_get, Swig_var_TradeReportTransType_CANCEL_set);
  SWIG_addvarlink(globals, "TradeReportTransType_RELEASE", Swig_var_TradeReportTransType_RELEASE_get, Swig_var_TradeReportTransType_RELEASE_set);
  SWIG_addvarlink(globals, "TradeReportTransType_REVERSE", Swig_var_TradeReportTransType_REVERSE_get, Swig_var_TradeReportTransType_REVERSE_set);
  SWIG_addvarlink(globals, "TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE", Swig_var_TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE_get, Swig_var_TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE_set);
  SWIG_addvarlink(globals, "PaymentMethod_BPAY", Swig_var_PaymentMethod_BPAY_get, Swig_var_PaymentMethod_BPAY_set);
  SWIG_addvarlink(globals, "PaymentMethod_ACH_CREDIT", Swig_var_PaymentMethod_ACH_CREDIT_get, Swig_var_PaymentMethod_ACH_CREDIT_set);
  SWIG_addvarlink(globals, "PaymentMethod_ACH_DEBIT", Swig_var_PaymentMethod_ACH_DEBIT_get, Swig_var_PaymentMethod_ACH_DEBIT_set);
  SWIG_addvarlink(globals, "PaymentMethod_CREDIT_CARD", Swig_var_PaymentMethod_CREDIT_CARD_get, Swig_var_PaymentMethod_CREDIT_CARD_set);
  SWIG_addvarlink(globals, "PaymentMethod_DIRECT_CREDIT", Swig_var_PaymentMethod_DIRECT_CREDIT_get, Swig_var_PaymentMethod_DIRECT_CREDIT_set);
  SWIG_addvarlink(globals, "PaymentMethod_DIRECT_DEBIT", Swig_var_PaymentMethod_DIRECT_DEBIT_get, Swig_var_PaymentMethod_DIRECT_DEBIT_set);
  SWIG_addvarlink(globals, "PaymentMethod_DEBIT_CARD", Swig_var_PaymentMethod_DEBIT_CARD_get, Swig_var_PaymentMethod_DEBIT_CARD_set);
  SWIG_addvarlink(globals, "PaymentMethod_FED_WIRE", Swig_var_PaymentMethod_FED_WIRE_get, Swig_var_PaymentMethod_FED_WIRE_set);
  SWIG_addvarlink(globals, "PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM", Swig_var_PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_get, Swig_var_PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_set);
  SWIG_addvarlink(globals, "PaymentMethod_EUROCLEAR", Swig_var_PaymentMethod_EUROCLEAR_get, Swig_var_PaymentMethod_EUROCLEAR_set);
  SWIG_addvarlink(globals, "PaymentMethod_TELEGRAPHIC_TRANSFER", Swig_var_PaymentMethod_TELEGRAPHIC_TRANSFER_get, Swig_var_PaymentMethod_TELEGRAPHIC_TRANSFER_set);
  SWIG_addvarlink(globals, "PaymentMethod_CLEARSTREAM", Swig_var_PaymentMethod_CLEARSTREAM_get, Swig_var_PaymentMethod_CLEARSTREAM_set);
  SWIG_addvarlink(globals, "PaymentMethod_CREST", Swig_var_PaymentMethod_CREST_get, Swig_var_PaymentMethod_CREST_set);
  SWIG_addvarlink(globals, "PaymentMethod_NSCC", Swig_var_PaymentMethod_NSCC_get, Swig_var_PaymentMethod_NSCC_set);
  SWIG_addvarlink(globals, "PaymentMethod_CHEQUE", Swig_var_PaymentMethod_CHEQUE_get, Swig_var_PaymentMethod_CHEQUE_set);
  SWIG_addvarlink(globals, "PaymentMethod_CHIPS", Swig_var_PaymentMethod_CHIPS_get, Swig_var_PaymentMethod_CHIPS_set);
  SWIG_addvarlink(globals, "PaymentMethod_SWIFT", Swig_var_PaymentMethod_SWIFT_get, Swig_var_PaymentMethod_SWIFT_set);
  SWIG_addvarlink(globals, "PaymentMethod_CHAPS", Swig_var_PaymentMethod_CHAPS_get, Swig_var_PaymentMethod_CHAPS_set);
  SWIG_addvarlink(globals, "PaymentMethod_SIC", Swig_var_PaymentMethod_SIC_get, Swig_var_PaymentMethod_SIC_set);
  SWIG_addvarlink(globals, "PaymentMethod_EURO_SIC", Swig_var_PaymentMethod_EURO_SIC_get, Swig_var_PaymentMethod_EURO_SIC_set);
  SWIG_addvarlink(globals, "PaymentMethod_OTHER", Swig_var_PaymentMethod_OTHER_get, Swig_var_PaymentMethod_OTHER_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_PROFIT_SHARING_PLAN", Swig_var_TaxAdvantageType_PROFIT_SHARING_PLAN_get, Swig_var_TaxAdvantageType_PROFIT_SHARING_PLAN_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_EMPLOYER_PRIOR_YEAR", Swig_var_TaxAdvantageType_EMPLOYER_PRIOR_YEAR_get, Swig_var_TaxAdvantageType_EMPLOYER_PRIOR_YEAR_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_EMPLOYER_CURRENT_YEAR", Swig_var_TaxAdvantageType_EMPLOYER_CURRENT_YEAR_get, Swig_var_TaxAdvantageType_EMPLOYER_CURRENT_YEAR_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_NON_FUND_PROTOTYPE_IRA", Swig_var_TaxAdvantageType_NON_FUND_PROTOTYPE_IRA_get, Swig_var_TaxAdvantageType_NON_FUND_PROTOTYPE_IRA_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_NON_FUND_QUALIFIED_PLAN", Swig_var_TaxAdvantageType_NON_FUND_QUALIFIED_PLAN_get, Swig_var_TaxAdvantageType_NON_FUND_QUALIFIED_PLAN_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN", Swig_var_TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN_get, Swig_var_TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_EMPLOYEE_CURRENT_YEAR", Swig_var_TaxAdvantageType_EMPLOYEE_CURRENT_YEAR_get, Swig_var_TaxAdvantageType_EMPLOYEE_CURRENT_YEAR_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_IRA_ROLLOVER", Swig_var_TaxAdvantageType_IRA_ROLLOVER_get, Swig_var_TaxAdvantageType_IRA_ROLLOVER_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_MINI_INSURANCE_ISA", Swig_var_TaxAdvantageType_MINI_INSURANCE_ISA_get, Swig_var_TaxAdvantageType_MINI_INSURANCE_ISA_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_IRA", Swig_var_TaxAdvantageType_IRA_get, Swig_var_TaxAdvantageType_IRA_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_EMPLOYEE_PRIOR_YEAR", Swig_var_TaxAdvantageType_EMPLOYEE_PRIOR_YEAR_get, Swig_var_TaxAdvantageType_EMPLOYEE_PRIOR_YEAR_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_ASSET_TRANSFER", Swig_var_TaxAdvantageType_ASSET_TRANSFER_get, Swig_var_TaxAdvantageType_ASSET_TRANSFER_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_SELF_DIRECTED_IRA", Swig_var_TaxAdvantageType_SELF_DIRECTED_IRA_get, Swig_var_TaxAdvantageType_SELF_DIRECTED_IRA_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_CURRENT_YEAR_PAYMENT", Swig_var_TaxAdvantageType_CURRENT_YEAR_PAYMENT_get, Swig_var_TaxAdvantageType_CURRENT_YEAR_PAYMENT_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_US401_K", Swig_var_TaxAdvantageType_US401_K_get, Swig_var_TaxAdvantageType_US401_K_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA", Swig_var_TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA_get, Swig_var_TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_MINI_CASH_ISA", Swig_var_TaxAdvantageType_MINI_CASH_ISA_get, Swig_var_TaxAdvantageType_MINI_CASH_ISA_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_TESSA", Swig_var_TaxAdvantageType_TESSA_get, Swig_var_TaxAdvantageType_TESSA_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_MAXI_ISA", Swig_var_TaxAdvantageType_MAXI_ISA_get, Swig_var_TaxAdvantageType_MAXI_ISA_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_NONE", Swig_var_TaxAdvantageType_NONE_get, Swig_var_TaxAdvantageType_NONE_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_PRIOR_YEAR_PAYMENT", Swig_var_TaxAdvantageType_PRIOR_YEAR_PAYMENT_get, Swig_var_TaxAdvantageType_PRIOR_YEAR_PAYMENT_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_US457", Swig_var_TaxAdvantageType_US457_get, Swig_var_TaxAdvantageType_US457_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_ROTH_IRA_PROTOTYPE", Swig_var_TaxAdvantageType_ROTH_IRA_PROTOTYPE_get, Swig_var_TaxAdvantageType_ROTH_IRA_PROTOTYPE_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_ROTH_IRA_NON_PROTOTYPE", Swig_var_TaxAdvantageType_ROTH_IRA_NON_PROTOTYPE_get, Swig_var_TaxAdvantageType_ROTH_IRA_NON_PROTOTYPE_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_ROTH_CONVERSION_IRA_PROTOTYPE", Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_PROTOTYPE_get, Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_PROTOTYPE_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_ROTH_CONVERSION_IRA_NON_PROTOTYPE", Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_NON_PROTOTYPE_get, Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_NON_PROTOTYPE_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_EDUCATION_IRA_PROTOTYPE", Swig_var_TaxAdvantageType_EDUCATION_IRA_PROTOTYPE_get, Swig_var_TaxAdvantageType_EDUCATION_IRA_PROTOTYPE_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_EDUCATION_IRA_NON_PROTOTYPE", Swig_var_TaxAdvantageType_EDUCATION_IRA_NON_PROTOTYPE_get, Swig_var_TaxAdvantageType_EDUCATION_IRA_NON_PROTOTYPE_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_KEOGH", Swig_var_TaxAdvantageType_KEOGH_get, Swig_var_TaxAdvantageType_KEOGH_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_US403B", Swig_var_TaxAdvantageType_US403B_get, Swig_var_TaxAdvantageType_US403B_set);
  SWIG_addvarlink(globals, "TaxAdvantageType_OTHER", Swig_var_TaxAdvantageType_OTHER_get, Swig_var_TaxAdvantageType_OTHER_set);
  SWIG_addvarlink(globals, "FundRenewWaiv_NO", Swig_var_FundRenewWaiv_NO_get, Swig_var_FundRenewWaiv_NO_set);
  SWIG_addvarlink(globals, "FundRenewWaiv_YES", Swig_var_FundRenewWaiv_YES_get, Swig_var_FundRenewWaiv_YES_set);
  SWIG_addvarlink(globals, "RegistStatus_ACCEPTED", Swig_var_RegistStatus_ACCEPTED_get, Swig_var_RegistStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "RegistStatus_REMINDER", Swig_var_RegistStatus_REMINDER_get, Swig_var_RegistStatus_REMINDER_set);
  SWIG_addvarlink(globals, "RegistStatus_REJECTED", Swig_var_RegistStatus_REJECTED_get, Swig_var_RegistStatus_REJECTED_set);
  SWIG_addvarlink(globals, "RegistStatus_HELD", Swig_var_RegistStatus_HELD_get, Swig_var_RegistStatus_HELD_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_DISTRIB_INSTNS", Swig_var_RegistRejReasonCode_INVALID_DISTRIB_INSTNS_get, Swig_var_RegistRejReasonCode_INVALID_DISTRIB_INSTNS_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_AGENT_CODE", Swig_var_RegistRejReasonCode_INVALID_AGENT_CODE_get, Swig_var_RegistRejReasonCode_INVALID_AGENT_CODE_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_ACCOUNT_NAME", Swig_var_RegistRejReasonCode_INVALID_ACCOUNT_NAME_get, Swig_var_RegistRejReasonCode_INVALID_ACCOUNT_NAME_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_NO_REG_DETAILS", Swig_var_RegistRejReasonCode_NO_REG_DETAILS_get, Swig_var_RegistRejReasonCode_NO_REG_DETAILS_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_PAYMENT_METHOD", Swig_var_RegistRejReasonCode_INVALID_PAYMENT_METHOD_get, Swig_var_RegistRejReasonCode_INVALID_PAYMENT_METHOD_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_PERCENTAGE", Swig_var_RegistRejReasonCode_INVALID_PERCENTAGE_get, Swig_var_RegistRejReasonCode_INVALID_PERCENTAGE_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_OWNERSHIP_TYPE", Swig_var_RegistRejReasonCode_INVALID_OWNERSHIP_TYPE_get, Swig_var_RegistRejReasonCode_INVALID_OWNERSHIP_TYPE_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_TAX_EXEMPT_TYPE", Swig_var_RegistRejReasonCode_INVALID_TAX_EXEMPT_TYPE_get, Swig_var_RegistRejReasonCode_INVALID_TAX_EXEMPT_TYPE_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_COUNTRY", Swig_var_RegistRejReasonCode_INVALID_COUNTRY_get, Swig_var_RegistRejReasonCode_INVALID_COUNTRY_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_DATE_OF_BIRTH", Swig_var_RegistRejReasonCode_INVALID_DATE_OF_BIRTH_get, Swig_var_RegistRejReasonCode_INVALID_DATE_OF_BIRTH_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_INVESTOR_ID_SOURCE", Swig_var_RegistRejReasonCode_INVALID_INVESTOR_ID_SOURCE_get, Swig_var_RegistRejReasonCode_INVALID_INVESTOR_ID_SOURCE_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_INVESTOR_ID", Swig_var_RegistRejReasonCode_INVALID_INVESTOR_ID_get, Swig_var_RegistRejReasonCode_INVALID_INVESTOR_ID_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_MAILING_INSTRUCTIONS", Swig_var_RegistRejReasonCode_INVALID_MAILING_INSTRUCTIONS_get, Swig_var_RegistRejReasonCode_INVALID_MAILING_INSTRUCTIONS_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_MAILING_DETAILS", Swig_var_RegistRejReasonCode_INVALID_MAILING_DETAILS_get, Swig_var_RegistRejReasonCode_INVALID_MAILING_DETAILS_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_REG_SEQ_NO", Swig_var_RegistRejReasonCode_INVALID_REG_SEQ_NO_get, Swig_var_RegistRejReasonCode_INVALID_REG_SEQ_NO_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_ACCOUNT_TYPE", Swig_var_RegistRejReasonCode_INVALID_ACCOUNT_TYPE_get, Swig_var_RegistRejReasonCode_INVALID_ACCOUNT_TYPE_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_ACCOUNT_NUM", Swig_var_RegistRejReasonCode_INVALID_ACCOUNT_NUM_get, Swig_var_RegistRejReasonCode_INVALID_ACCOUNT_NUM_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_INVALID_REG_DETAILS", Swig_var_RegistRejReasonCode_INVALID_REG_DETAILS_get, Swig_var_RegistRejReasonCode_INVALID_REG_DETAILS_set);
  SWIG_addvarlink(globals, "RegistRejReasonCode_OTHER", Swig_var_RegistRejReasonCode_OTHER_get, Swig_var_RegistRejReasonCode_OTHER_set);
  SWIG_addvarlink(globals, "RegistTransType_CANCEL", Swig_var_RegistTransType_CANCEL_get, Swig_var_RegistTransType_CANCEL_set);
  SWIG_addvarlink(globals, "RegistTransType_NEW", Swig_var_RegistTransType_NEW_get, Swig_var_RegistTransType_NEW_set);
  SWIG_addvarlink(globals, "RegistTransType_REPLACE", Swig_var_RegistTransType_REPLACE_get, Swig_var_RegistTransType_REPLACE_set);
  SWIG_addvarlink(globals, "OwnershipType_JOINT_INVESTORS", Swig_var_OwnershipType_JOINT_INVESTORS_get, Swig_var_OwnershipType_JOINT_INVESTORS_set);
  SWIG_addvarlink(globals, "OwnershipType_TENANTS_IN_COMMON", Swig_var_OwnershipType_TENANTS_IN_COMMON_get, Swig_var_OwnershipType_TENANTS_IN_COMMON_set);
  SWIG_addvarlink(globals, "OwnershipType_JOINT_TRUSTEES", Swig_var_OwnershipType_JOINT_TRUSTEES_get, Swig_var_OwnershipType_JOINT_TRUSTEES_set);
  SWIG_addvarlink(globals, "ContAmtType_NET_SETTLEMENT_AMOUNT", Swig_var_ContAmtType_NET_SETTLEMENT_AMOUNT_get, Swig_var_ContAmtType_NET_SETTLEMENT_AMOUNT_set);
  SWIG_addvarlink(globals, "ContAmtType_COMMISSION_AMOUNT", Swig_var_ContAmtType_COMMISSION_AMOUNT_get, Swig_var_ContAmtType_COMMISSION_AMOUNT_set);
  SWIG_addvarlink(globals, "ContAmtType_COMMISSION_PERCENT", Swig_var_ContAmtType_COMMISSION_PERCENT_get, Swig_var_ContAmtType_COMMISSION_PERCENT_set);
  SWIG_addvarlink(globals, "ContAmtType_INITIAL_CHARGE_AMOUNT", Swig_var_ContAmtType_INITIAL_CHARGE_AMOUNT_get, Swig_var_ContAmtType_INITIAL_CHARGE_AMOUNT_set);
  SWIG_addvarlink(globals, "ContAmtType_INITIAL_CHARGE_PERCENT", Swig_var_ContAmtType_INITIAL_CHARGE_PERCENT_get, Swig_var_ContAmtType_INITIAL_CHARGE_PERCENT_set);
  SWIG_addvarlink(globals, "ContAmtType_DISCOUNT_AMOUNT", Swig_var_ContAmtType_DISCOUNT_AMOUNT_get, Swig_var_ContAmtType_DISCOUNT_AMOUNT_set);
  SWIG_addvarlink(globals, "ContAmtType_DISCOUNT_PERCENT", Swig_var_ContAmtType_DISCOUNT_PERCENT_get, Swig_var_ContAmtType_DISCOUNT_PERCENT_set);
  SWIG_addvarlink(globals, "ContAmtType_DILUTION_LEVY_AMOUNT", Swig_var_ContAmtType_DILUTION_LEVY_AMOUNT_get, Swig_var_ContAmtType_DILUTION_LEVY_AMOUNT_set);
  SWIG_addvarlink(globals, "ContAmtType_DILUTION_LEVY_PERCENT", Swig_var_ContAmtType_DILUTION_LEVY_PERCENT_get, Swig_var_ContAmtType_DILUTION_LEVY_PERCENT_set);
  SWIG_addvarlink(globals, "ContAmtType_EXIT_CHARGE_AMOUNT", Swig_var_ContAmtType_EXIT_CHARGE_AMOUNT_get, Swig_var_ContAmtType_EXIT_CHARGE_AMOUNT_set);
  SWIG_addvarlink(globals, "ContAmtType_EXIT_CHARGE_PERCENT", Swig_var_ContAmtType_EXIT_CHARGE_PERCENT_get, Swig_var_ContAmtType_EXIT_CHARGE_PERCENT_set);
  SWIG_addvarlink(globals, "ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT", Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT_get, Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT_set);
  SWIG_addvarlink(globals, "ContAmtType_PROJECTED_FUND_VALUE", Swig_var_ContAmtType_PROJECTED_FUND_VALUE_get, Swig_var_ContAmtType_PROJECTED_FUND_VALUE_set);
  SWIG_addvarlink(globals, "ContAmtType_FUND_BASED_RENEWAL_COMMISSION_ON_FUND", Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_ON_FUND_get, Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_ON_FUND_set);
  SWIG_addvarlink(globals, "ContAmtType_FUND_BASED_RENEWAL_COMMISSION_ON_ORDER", Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_ON_ORDER_get, Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_ON_ORDER_set);
  SWIG_addvarlink(globals, "OwnerType_COMPANY_TRUSTEE", Swig_var_OwnerType_COMPANY_TRUSTEE_get, Swig_var_OwnerType_COMPANY_TRUSTEE_set);
  SWIG_addvarlink(globals, "OwnerType_NOMINEE", Swig_var_OwnerType_NOMINEE_get, Swig_var_OwnerType_NOMINEE_set);
  SWIG_addvarlink(globals, "OwnerType_CORPORATE_BODY", Swig_var_OwnerType_CORPORATE_BODY_get, Swig_var_OwnerType_CORPORATE_BODY_set);
  SWIG_addvarlink(globals, "OwnerType_NON_PROFIT_ORGANIZATION", Swig_var_OwnerType_NON_PROFIT_ORGANIZATION_get, Swig_var_OwnerType_NON_PROFIT_ORGANIZATION_set);
  SWIG_addvarlink(globals, "OwnerType_NETWORKING_SUB_ACCOUNT", Swig_var_OwnerType_NETWORKING_SUB_ACCOUNT_get, Swig_var_OwnerType_NETWORKING_SUB_ACCOUNT_set);
  SWIG_addvarlink(globals, "OwnerType_FIDUCIARIES", Swig_var_OwnerType_FIDUCIARIES_get, Swig_var_OwnerType_FIDUCIARIES_set);
  SWIG_addvarlink(globals, "OwnerType_TRUSTS", Swig_var_OwnerType_TRUSTS_get, Swig_var_OwnerType_TRUSTS_set);
  SWIG_addvarlink(globals, "OwnerType_PENSION_PLAN", Swig_var_OwnerType_PENSION_PLAN_get, Swig_var_OwnerType_PENSION_PLAN_set);
  SWIG_addvarlink(globals, "OwnerType_INDIVIDUAL_TRUSTEE", Swig_var_OwnerType_INDIVIDUAL_TRUSTEE_get, Swig_var_OwnerType_INDIVIDUAL_TRUSTEE_set);
  SWIG_addvarlink(globals, "OwnerType_PUBLIC_COMPANY", Swig_var_OwnerType_PUBLIC_COMPANY_get, Swig_var_OwnerType_PUBLIC_COMPANY_set);
  SWIG_addvarlink(globals, "OwnerType_PRIVATE_COMPANY", Swig_var_OwnerType_PRIVATE_COMPANY_get, Swig_var_OwnerType_PRIVATE_COMPANY_set);
  SWIG_addvarlink(globals, "OwnerType_INDIVIDUAL_INVESTOR", Swig_var_OwnerType_INDIVIDUAL_INVESTOR_get, Swig_var_OwnerType_INDIVIDUAL_INVESTOR_set);
  SWIG_addvarlink(globals, "OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT", Swig_var_OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT_get, Swig_var_OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT_set);
  SWIG_addvarlink(globals, "OwnerType_INSTITUTIONAL_CUSTOMER", Swig_var_OwnerType_INSTITUTIONAL_CUSTOMER_get, Swig_var_OwnerType_INSTITUTIONAL_CUSTOMER_set);
  SWIG_addvarlink(globals, "OwnerType_COMBINED", Swig_var_OwnerType_COMBINED_get, Swig_var_OwnerType_COMBINED_set);
  SWIG_addvarlink(globals, "OwnerType_MEMBER_FIRM_EMPLOYEE", Swig_var_OwnerType_MEMBER_FIRM_EMPLOYEE_get, Swig_var_OwnerType_MEMBER_FIRM_EMPLOYEE_set);
  SWIG_addvarlink(globals, "OwnerType_MARKET_MAKING_ACCOUNT", Swig_var_OwnerType_MARKET_MAKING_ACCOUNT_get, Swig_var_OwnerType_MARKET_MAKING_ACCOUNT_set);
  SWIG_addvarlink(globals, "OwnerType_PROPRIETARY_ACCOUNT", Swig_var_OwnerType_PROPRIETARY_ACCOUNT_get, Swig_var_OwnerType_PROPRIETARY_ACCOUNT_set);
  SWIG_addvarlink(globals, "OwnerType_NONBROKER_DEALER", Swig_var_OwnerType_NONBROKER_DEALER_get, Swig_var_OwnerType_NONBROKER_DEALER_set);
  SWIG_addvarlink(globals, "OwnerType_UNKNOWN_BENEFICIAL_OWNER_TYPE", Swig_var_OwnerType_UNKNOWN_BENEFICIAL_OWNER_TYPE_get, Swig_var_OwnerType_UNKNOWN_BENEFICIAL_OWNER_TYPE_set);
  SWIG_addvarlink(globals, "OwnerType_FIRMS_ERROR_ACCOUNT", Swig_var_OwnerType_FIRMS_ERROR_ACCOUNT_get, Swig_var_OwnerType_FIRMS_ERROR_ACCOUNT_set);
  SWIG_addvarlink(globals, "OwnerType_FIRM_AGENCY_AVERAGE_PRICE_ACCOUNT", Swig_var_OwnerType_FIRM_AGENCY_AVERAGE_PRICE_ACCOUNT_get, Swig_var_OwnerType_FIRM_AGENCY_AVERAGE_PRICE_ACCOUNT_set);
  SWIG_addvarlink(globals, "OrderCapacity_RISKLESS_PRINCIPAL", Swig_var_OrderCapacity_RISKLESS_PRINCIPAL_get, Swig_var_OrderCapacity_RISKLESS_PRINCIPAL_set);
  SWIG_addvarlink(globals, "OrderCapacity_INDIVIDUAL", Swig_var_OrderCapacity_INDIVIDUAL_get, Swig_var_OrderCapacity_INDIVIDUAL_set);
  SWIG_addvarlink(globals, "OrderCapacity_PRINCIPAL", Swig_var_OrderCapacity_PRINCIPAL_get, Swig_var_OrderCapacity_PRINCIPAL_set);
  SWIG_addvarlink(globals, "OrderCapacity_AGENT_FOR_OTHER_MEMBER", Swig_var_OrderCapacity_AGENT_FOR_OTHER_MEMBER_get, Swig_var_OrderCapacity_AGENT_FOR_OTHER_MEMBER_set);
  SWIG_addvarlink(globals, "OrderCapacity_AGENCY", Swig_var_OrderCapacity_AGENCY_get, Swig_var_OrderCapacity_AGENCY_set);
  SWIG_addvarlink(globals, "OrderCapacity_PROPRIETARY", Swig_var_OrderCapacity_PROPRIETARY_get, Swig_var_OrderCapacity_PROPRIETARY_set);
  SWIG_addvarlink(globals, "OrderCapacity_MIXED_CAPACITY", Swig_var_OrderCapacity_MIXED_CAPACITY_get, Swig_var_OrderCapacity_MIXED_CAPACITY_set);
  SWIG_addvarlink(globals, "OrderRestrictions_FOREIGN_ENTITY", Swig_var_OrderRestrictions_FOREIGN_ENTITY_get, Swig_var_OrderRestrictions_FOREIGN_ENTITY_set);
  SWIG_addvarlink(globals, "OrderRestrictions_RISKLESS_ARBITRAGE", Swig_var_OrderRestrictions_RISKLESS_ARBITRAGE_get, Swig_var_OrderRestrictions_RISKLESS_ARBITRAGE_set);
  SWIG_addvarlink(globals, "OrderRestrictions_PROGRAM_TRADE", Swig_var_OrderRestrictions_PROGRAM_TRADE_get, Swig_var_OrderRestrictions_PROGRAM_TRADE_set);
  SWIG_addvarlink(globals, "OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT", Swig_var_OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT_get, Swig_var_OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT_set);
  SWIG_addvarlink(globals, "OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_UNDERLYING", Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_UNDERLYING_get, Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_UNDERLYING_set);
  SWIG_addvarlink(globals, "OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_SECURITY", Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_SECURITY_get, Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_SECURITY_set);
  SWIG_addvarlink(globals, "OrderRestrictions_NON_INDEX_ARBITRAGE", Swig_var_OrderRestrictions_NON_INDEX_ARBITRAGE_get, Swig_var_OrderRestrictions_NON_INDEX_ARBITRAGE_set);
  SWIG_addvarlink(globals, "OrderRestrictions_INDEX_ARBITRAGE", Swig_var_OrderRestrictions_INDEX_ARBITRAGE_get, Swig_var_OrderRestrictions_INDEX_ARBITRAGE_set);
  SWIG_addvarlink(globals, "OrderRestrictions_COMPETING_MARKET_MAKER", Swig_var_OrderRestrictions_COMPETING_MARKET_MAKER_get, Swig_var_OrderRestrictions_COMPETING_MARKET_MAKER_set);
  SWIG_addvarlink(globals, "OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE", Swig_var_OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE_get, Swig_var_OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE_set);
  SWIG_addvarlink(globals, "OrderRestrictions_ISSUER_HOLDING", Swig_var_OrderRestrictions_ISSUER_HOLDING_get, Swig_var_OrderRestrictions_ISSUER_HOLDING_set);
  SWIG_addvarlink(globals, "OrderRestrictions_ISSUE_PRICE_STABILIZATION", Swig_var_OrderRestrictions_ISSUE_PRICE_STABILIZATION_get, Swig_var_OrderRestrictions_ISSUE_PRICE_STABILIZATION_set);
  SWIG_addvarlink(globals, "OrderRestrictions_NON_ALGORITHMIC", Swig_var_OrderRestrictions_NON_ALGORITHMIC_get, Swig_var_OrderRestrictions_NON_ALGORITHMIC_set);
  SWIG_addvarlink(globals, "OrderRestrictions_ALGORITHMIC", Swig_var_OrderRestrictions_ALGORITHMIC_get, Swig_var_OrderRestrictions_ALGORITHMIC_set);
  SWIG_addvarlink(globals, "OrderRestrictions_CROSS", Swig_var_OrderRestrictions_CROSS_get, Swig_var_OrderRestrictions_CROSS_set);
  SWIG_addvarlink(globals, "OrderRestrictions_INSIDER_ACCOUNT", Swig_var_OrderRestrictions_INSIDER_ACCOUNT_get, Swig_var_OrderRestrictions_INSIDER_ACCOUNT_set);
  SWIG_addvarlink(globals, "OrderRestrictions_SIGNIFICANT_SHAREHOLDER", Swig_var_OrderRestrictions_SIGNIFICANT_SHAREHOLDER_get, Swig_var_OrderRestrictions_SIGNIFICANT_SHAREHOLDER_set);
  SWIG_addvarlink(globals, "OrderRestrictions_NORMAL_COURSE_ISSUER_BID", Swig_var_OrderRestrictions_NORMAL_COURSE_ISSUER_BID_get, Swig_var_OrderRestrictions_NORMAL_COURSE_ISSUER_BID_set);
  SWIG_addvarlink(globals, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY", Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_set);
  SWIG_addvarlink(globals, "MassCancelRequestType_CANCEL_ALL_ORDERS", Swig_var_MassCancelRequestType_CANCEL_ALL_ORDERS_get, Swig_var_MassCancelRequestType_CANCEL_ALL_ORDERS_set);
  SWIG_addvarlink(globals, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION", Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION_set);
  SWIG_addvarlink(globals, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_TYPE", Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_TYPE_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_TYPE_set);
  SWIG_addvarlink(globals, "MassCancelRequestType_CANCEL_ORDERS_FOR_ACFI_CODE", Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_ACFI_CODE_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_ACFI_CODE_set);
  SWIG_addvarlink(globals, "MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY", Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT", Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT_set);
  SWIG_addvarlink(globals, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET", Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_set);
  SWIG_addvarlink(globals, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT", Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_set);
  SWIG_addvarlink(globals, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP", Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_set);
  SWIG_addvarlink(globals, "MassCancelRequestType_CANCEL_ORDERS_FOR_SECURITY_ISSUER", Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_SECURITY_ISSUER_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_SECURITY_ISSUER_set);
  SWIG_addvarlink(globals, "MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY", Swig_var_MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION", Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION_set);
  SWIG_addvarlink(globals, "MassCancelResponse_CANCEL_REQUEST_REJECTED", Swig_var_MassCancelResponse_CANCEL_REQUEST_REJECTED_get, Swig_var_MassCancelResponse_CANCEL_REQUEST_REJECTED_set);
  SWIG_addvarlink(globals, "MassCancelResponse_CANCEL_ALL_ORDERS", Swig_var_MassCancelResponse_CANCEL_ALL_ORDERS_get, Swig_var_MassCancelResponse_CANCEL_ALL_ORDERS_set);
  SWIG_addvarlink(globals, "MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT", Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT_set);
  SWIG_addvarlink(globals, "MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_TYPE", Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_TYPE_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_TYPE_set);
  SWIG_addvarlink(globals, "MassCancelResponse_CANCEL_ORDERS_FOR_ACFI_CODE", Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_ACFI_CODE_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_ACFI_CODE_set);
  SWIG_addvarlink(globals, "MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY", Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_set);
  SWIG_addvarlink(globals, "MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY", Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET", Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_set);
  SWIG_addvarlink(globals, "MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT", Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_set);
  SWIG_addvarlink(globals, "MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP", Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_set);
  SWIG_addvarlink(globals, "MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER", Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER_set);
  SWIG_addvarlink(globals, "MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY", Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY", Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION", Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_set);
  SWIG_addvarlink(globals, "MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE", Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_set);
  SWIG_addvarlink(globals, "MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT", Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT_set);
  SWIG_addvarlink(globals, "MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY", Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_set);
  SWIG_addvarlink(globals, "MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED", Swig_var_MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED_get, Swig_var_MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "MassCancelRejectReason_INVALID_OR_UNKNOWN_CFI_CODE", Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_CFI_CODE_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_CFI_CODE_set);
  SWIG_addvarlink(globals, "MassCancelRejectReason_OTHER", Swig_var_MassCancelRejectReason_OTHER_get, Swig_var_MassCancelRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET", Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET_set);
  SWIG_addvarlink(globals, "MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT", Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT_set);
  SWIG_addvarlink(globals, "MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP", Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_set);
  SWIG_addvarlink(globals, "MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY", Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER", Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set);
  SWIG_addvarlink(globals, "MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY", Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "QuoteType_INDICATIVE", Swig_var_QuoteType_INDICATIVE_get, Swig_var_QuoteType_INDICATIVE_set);
  SWIG_addvarlink(globals, "QuoteType_TRADEABLE", Swig_var_QuoteType_TRADEABLE_get, Swig_var_QuoteType_TRADEABLE_set);
  SWIG_addvarlink(globals, "QuoteType_RESTRICTED_TRADEABLE", Swig_var_QuoteType_RESTRICTED_TRADEABLE_get, Swig_var_QuoteType_RESTRICTED_TRADEABLE_set);
  SWIG_addvarlink(globals, "QuoteType_COUNTER", Swig_var_QuoteType_COUNTER_get, Swig_var_QuoteType_COUNTER_set);
  SWIG_addvarlink(globals, "QuoteType_INITIALLY_TRADEABLE", Swig_var_QuoteType_INITIALLY_TRADEABLE_get, Swig_var_QuoteType_INITIALLY_TRADEABLE_set);
  SWIG_addvarlink(globals, "CashMargin_MARGIN_OPEN", Swig_var_CashMargin_MARGIN_OPEN_get, Swig_var_CashMargin_MARGIN_OPEN_set);
  SWIG_addvarlink(globals, "CashMargin_MARGIN_CLOSE", Swig_var_CashMargin_MARGIN_CLOSE_get, Swig_var_CashMargin_MARGIN_CLOSE_set);
  SWIG_addvarlink(globals, "CashMargin_CASH", Swig_var_CashMargin_CASH_get, Swig_var_CashMargin_CASH_set);
  SWIG_addvarlink(globals, "Scope_LOCAL_MARKET", Swig_var_Scope_LOCAL_MARKET_get, Swig_var_Scope_LOCAL_MARKET_set);
  SWIG_addvarlink(globals, "Scope_NATIONAL", Swig_var_Scope_NATIONAL_get, Swig_var_Scope_NATIONAL_set);
  SWIG_addvarlink(globals, "Scope_GLOBAL", Swig_var_Scope_GLOBAL_get, Swig_var_Scope_GLOBAL_set);
  SWIG_addvarlink(globals, "MDImplicitDelete_YES", Swig_var_MDImplicitDelete_YES_get, Swig_var_MDImplicitDelete_YES_set);
  SWIG_addvarlink(globals, "MDImplicitDelete_NO", Swig_var_MDImplicitDelete_NO_get, Swig_var_MDImplicitDelete_NO_set);
  SWIG_addvarlink(globals, "CrossType_CROSS_AON", Swig_var_CrossType_CROSS_AON_get, Swig_var_CrossType_CROSS_AON_set);
  SWIG_addvarlink(globals, "CrossType_CROSS_IOC", Swig_var_CrossType_CROSS_IOC_get, Swig_var_CrossType_CROSS_IOC_set);
  SWIG_addvarlink(globals, "CrossType_CROSS_ONE_SIDE", Swig_var_CrossType_CROSS_ONE_SIDE_get, Swig_var_CrossType_CROSS_ONE_SIDE_set);
  SWIG_addvarlink(globals, "CrossType_CROSS_SAME_PRICE", Swig_var_CrossType_CROSS_SAME_PRICE_get, Swig_var_CrossType_CROSS_SAME_PRICE_set);
  SWIG_addvarlink(globals, "CrossType_BASIS_CROSS", Swig_var_CrossType_BASIS_CROSS_get, Swig_var_CrossType_BASIS_CROSS_set);
  SWIG_addvarlink(globals, "CrossType_CONTINGENT_CROSS", Swig_var_CrossType_CONTINGENT_CROSS_get, Swig_var_CrossType_CONTINGENT_CROSS_set);
  SWIG_addvarlink(globals, "CrossType_VWAP_CROSS", Swig_var_CrossType_VWAP_CROSS_get, Swig_var_CrossType_VWAP_CROSS_set);
  SWIG_addvarlink(globals, "CrossType_STS_CROSS", Swig_var_CrossType_STS_CROSS_get, Swig_var_CrossType_STS_CROSS_set);
  SWIG_addvarlink(globals, "CrossType_CUSTOMER_TO_CUSTOMER", Swig_var_CrossType_CUSTOMER_TO_CUSTOMER_get, Swig_var_CrossType_CUSTOMER_TO_CUSTOMER_set);
  SWIG_addvarlink(globals, "CrossPrioritization_SELL_SIDE_IS_PRIORITIZED", Swig_var_CrossPrioritization_SELL_SIDE_IS_PRIORITIZED_get, Swig_var_CrossPrioritization_SELL_SIDE_IS_PRIORITIZED_set);
  SWIG_addvarlink(globals, "CrossPrioritization_NONE", Swig_var_CrossPrioritization_NONE_get, Swig_var_CrossPrioritization_NONE_set);
  SWIG_addvarlink(globals, "CrossPrioritization_BUY_SIDE_IS_PRIORITIZED", Swig_var_CrossPrioritization_BUY_SIDE_IS_PRIORITIZED_get, Swig_var_CrossPrioritization_BUY_SIDE_IS_PRIORITIZED_set);
  SWIG_addvarlink(globals, "NoSides_ONE_SIDE", Swig_var_NoSides_ONE_SIDE_get, Swig_var_NoSides_ONE_SIDE_set);
  SWIG_addvarlink(globals, "NoSides_BOTH_SIDES", Swig_var_NoSides_BOTH_SIDES_get, Swig_var_NoSides_BOTH_SIDES_set);
  SWIG_addvarlink(globals, "SecurityListRequestType_SECURITY_TYPE_AND", Swig_var_SecurityListRequestType_SECURITY_TYPE_AND_get, Swig_var_SecurityListRequestType_SECURITY_TYPE_AND_set);
  SWIG_addvarlink(globals, "SecurityListRequestType_PRODUCT", Swig_var_SecurityListRequestType_PRODUCT_get, Swig_var_SecurityListRequestType_PRODUCT_set);
  SWIG_addvarlink(globals, "SecurityListRequestType_TRADING_SESSION_ID", Swig_var_SecurityListRequestType_TRADING_SESSION_ID_get, Swig_var_SecurityListRequestType_TRADING_SESSION_ID_set);
  SWIG_addvarlink(globals, "SecurityListRequestType_ALL_SECURITIES", Swig_var_SecurityListRequestType_ALL_SECURITIES_get, Swig_var_SecurityListRequestType_ALL_SECURITIES_set);
  SWIG_addvarlink(globals, "SecurityListRequestType_SYMBOL", Swig_var_SecurityListRequestType_SYMBOL_get, Swig_var_SecurityListRequestType_SYMBOL_set);
  SWIG_addvarlink(globals, "SecurityListRequestType_MARKET_ID_OR_MARKET_ID", Swig_var_SecurityListRequestType_MARKET_ID_OR_MARKET_ID_get, Swig_var_SecurityListRequestType_MARKET_ID_OR_MARKET_ID_set);
  SWIG_addvarlink(globals, "SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE", Swig_var_SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE_get, Swig_var_SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE_set);
  SWIG_addvarlink(globals, "SecurityRequestResult_VALID_REQUEST", Swig_var_SecurityRequestResult_VALID_REQUEST_get, Swig_var_SecurityRequestResult_VALID_REQUEST_set);
  SWIG_addvarlink(globals, "SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST", Swig_var_SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_get, Swig_var_SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_set);
  SWIG_addvarlink(globals, "SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED", Swig_var_SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED_get, Swig_var_SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA", Swig_var_SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA_get, Swig_var_SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA_set);
  SWIG_addvarlink(globals, "SecurityRequestResult_NO_INSTRUMENTS_FOUND", Swig_var_SecurityRequestResult_NO_INSTRUMENTS_FOUND_get, Swig_var_SecurityRequestResult_NO_INSTRUMENTS_FOUND_set);
  SWIG_addvarlink(globals, "MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY", Swig_var_MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY_get, Swig_var_MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY_set);
  SWIG_addvarlink(globals, "MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_INSTRUMENT_LEGS", Swig_var_MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_INSTRUMENT_LEGS_get, Swig_var_MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_INSTRUMENT_LEGS_set);
  SWIG_addvarlink(globals, "MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_ONLY", Swig_var_MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_ONLY_get, Swig_var_MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_ONLY_set);
  SWIG_addvarlink(globals, "TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADING_SESSION_ID", Swig_var_TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADING_SESSION_ID_get, Swig_var_TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADING_SESSION_ID_set);
  SWIG_addvarlink(globals, "TradSesStatusRejReason_OTHER", Swig_var_TradSesStatusRejReason_OTHER_get, Swig_var_TradSesStatusRejReason_OTHER_set);
  SWIG_addvarlink(globals, "TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA", Swig_var_TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA_get, Swig_var_TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA_set);
  SWIG_addvarlink(globals, "TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA", Swig_var_TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA_get, Swig_var_TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA_set);
  SWIG_addvarlink(globals, "TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA", Swig_var_TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA_get, Swig_var_TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA_set);
  SWIG_addvarlink(globals, "TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA", Swig_var_TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_get, Swig_var_TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_set);
  SWIG_addvarlink(globals, "TradeRequestType_ALL_TRADES", Swig_var_TradeRequestType_ALL_TRADES_get, Swig_var_TradeRequestType_ALL_TRADES_set);
  SWIG_addvarlink(globals, "PreviouslyReported_NO", Swig_var_PreviouslyReported_NO_get, Swig_var_PreviouslyReported_NO_set);
  SWIG_addvarlink(globals, "PreviouslyReported_YES", Swig_var_PreviouslyReported_YES_get, Swig_var_PreviouslyReported_YES_set);
  SWIG_addvarlink(globals, "MatchStatus_COMPARED", Swig_var_MatchStatus_COMPARED_get, Swig_var_MatchStatus_COMPARED_set);
  SWIG_addvarlink(globals, "MatchStatus_UNCOMPARED", Swig_var_MatchStatus_UNCOMPARED_get, Swig_var_MatchStatus_UNCOMPARED_set);
  SWIG_addvarlink(globals, "MatchStatus_ADVISORY_OR_ALERT", Swig_var_MatchStatus_ADVISORY_OR_ALERT_get, Swig_var_MatchStatus_ADVISORY_OR_ALERT_set);
  SWIG_addvarlink(globals, "MatchStatus_MISMATCHED", Swig_var_MatchStatus_MISMATCHED_get, Swig_var_MatchStatus_MISMATCHED_set);
  SWIG_addvarlink(globals, "MatchType_A5_EXACT_MATCH_SUMMARIZED_QUANTITY", Swig_var_MatchType_A5_EXACT_MATCH_SUMMARIZED_QUANTITY_get, Swig_var_MatchType_A5_EXACT_MATCH_SUMMARIZED_QUANTITY_set);
  SWIG_addvarlink(globals, "MatchType_EXACT_MATCH_MINUS_BADGES_TIMES", Swig_var_MatchType_EXACT_MATCH_MINUS_BADGES_TIMES_get, Swig_var_MatchType_EXACT_MATCH_MINUS_BADGES_TIMES_set);
  SWIG_addvarlink(globals, "MatchType_ACTM6_MATCH", Swig_var_MatchType_ACTM6_MATCH_get, Swig_var_MatchType_ACTM6_MATCH_set);
  SWIG_addvarlink(globals, "MatchType_ACT_DEFAULT_AFTER_M2", Swig_var_MatchType_ACT_DEFAULT_AFTER_M2_get, Swig_var_MatchType_ACT_DEFAULT_AFTER_M2_set);
  SWIG_addvarlink(globals, "MatchType_ACT_ACCEPTED_TRADE", Swig_var_MatchType_ACT_ACCEPTED_TRADE_get, Swig_var_MatchType_ACT_ACCEPTED_TRADE_set);
  SWIG_addvarlink(globals, "MatchType_A2_EXACT_MATCH_SUMMARIZED_QUANTITY", Swig_var_MatchType_A2_EXACT_MATCH_SUMMARIZED_QUANTITY_get, Swig_var_MatchType_A2_EXACT_MATCH_SUMMARIZED_QUANTITY_set);
  SWIG_addvarlink(globals, "MatchType_A3_EXACT_MATCH_SUMMARIZED_QUANTITY", Swig_var_MatchType_A3_EXACT_MATCH_SUMMARIZED_QUANTITY_get, Swig_var_MatchType_A3_EXACT_MATCH_SUMMARIZED_QUANTITY_set);
  SWIG_addvarlink(globals, "MatchType_A4_EXACT_MATCH_SUMMARIZED_QUANTITY", Swig_var_MatchType_A4_EXACT_MATCH_SUMMARIZED_QUANTITY_get, Swig_var_MatchType_A4_EXACT_MATCH_SUMMARIZED_QUANTITY_set);
  SWIG_addvarlink(globals, "MatchType_SUMMARIZED_MATCH_MINUS_BADGES_TIMES", Swig_var_MatchType_SUMMARIZED_MATCH_MINUS_BADGES_TIMES_get, Swig_var_MatchType_SUMMARIZED_MATCH_MINUS_BADGES_TIMES_set);
  SWIG_addvarlink(globals, "MatchType_EXACT_MATCH_PLUS4_BADGES", Swig_var_MatchType_EXACT_MATCH_PLUS4_BADGES_get, Swig_var_MatchType_EXACT_MATCH_PLUS4_BADGES_set);
  SWIG_addvarlink(globals, "MatchType_EXACT_MATCH_PLUS2_BADGES_EXEC_TIME", Swig_var_MatchType_EXACT_MATCH_PLUS2_BADGES_EXEC_TIME_get, Swig_var_MatchType_EXACT_MATCH_PLUS2_BADGES_EXEC_TIME_set);
  SWIG_addvarlink(globals, "MatchType_EXACT_MATCH_PLUS2_BADGES", Swig_var_MatchType_EXACT_MATCH_PLUS2_BADGES_get, Swig_var_MatchType_EXACT_MATCH_PLUS2_BADGES_set);
  SWIG_addvarlink(globals, "MatchType_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS", Swig_var_MatchType_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_get, Swig_var_MatchType_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_set);
  SWIG_addvarlink(globals, "MatchType_OCS_LOCKED_IN", Swig_var_MatchType_OCS_LOCKED_IN_get, Swig_var_MatchType_OCS_LOCKED_IN_set);
  SWIG_addvarlink(globals, "MatchType_ACT_DEFAULT_TRADE", Swig_var_MatchType_ACT_DEFAULT_TRADE_get, Swig_var_MatchType_ACT_DEFAULT_TRADE_set);
  SWIG_addvarlink(globals, "MatchType_EXACT_MATCH_PLUS4_BADGES_EXEC_TIME", Swig_var_MatchType_EXACT_MATCH_PLUS4_BADGES_EXEC_TIME_get, Swig_var_MatchType_EXACT_MATCH_PLUS4_BADGES_EXEC_TIME_set);
  SWIG_addvarlink(globals, "MatchType_A1_EXACT_MATCH_SUMMARIZED_QUANTITY", Swig_var_MatchType_A1_EXACT_MATCH_SUMMARIZED_QUANTITY_get, Swig_var_MatchType_A1_EXACT_MATCH_SUMMARIZED_QUANTITY_set);
  SWIG_addvarlink(globals, "MatchType_EXACT_MATCH_PLUS_EXEC_TIME", Swig_var_MatchType_EXACT_MATCH_PLUS_EXEC_TIME_get, Swig_var_MatchType_EXACT_MATCH_PLUS_EXEC_TIME_set);
  SWIG_addvarlink(globals, "MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT", Swig_var_MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get, Swig_var_MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_set);
  SWIG_addvarlink(globals, "MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT", Swig_var_MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get, Swig_var_MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_set);
  SWIG_addvarlink(globals, "MatchType_CONTINUOUS_AUTO_MATCH", Swig_var_MatchType_CONTINUOUS_AUTO_MATCH_get, Swig_var_MatchType_CONTINUOUS_AUTO_MATCH_set);
  SWIG_addvarlink(globals, "MatchType_CROSS_AUCTION", Swig_var_MatchType_CROSS_AUCTION_get, Swig_var_MatchType_CROSS_AUCTION_set);
  SWIG_addvarlink(globals, "MatchType_COUNTER_ORDER_SELECTION", Swig_var_MatchType_COUNTER_ORDER_SELECTION_get, Swig_var_MatchType_COUNTER_ORDER_SELECTION_set);
  SWIG_addvarlink(globals, "MatchType_CALL_AUCTION", Swig_var_MatchType_CALL_AUCTION_get, Swig_var_MatchType_CALL_AUCTION_set);
  SWIG_addvarlink(globals, "MatchType_ONE_PARTY_TRADE_REPORT", Swig_var_MatchType_ONE_PARTY_TRADE_REPORT_get, Swig_var_MatchType_ONE_PARTY_TRADE_REPORT_set);
  SWIG_addvarlink(globals, "MatchType_TWO_PARTY_TRADE_REPORT", Swig_var_MatchType_TWO_PARTY_TRADE_REPORT_get, Swig_var_MatchType_TWO_PARTY_TRADE_REPORT_set);
  SWIG_addvarlink(globals, "MatchType_CONFIRMED_TRADE_REPORT", Swig_var_MatchType_CONFIRMED_TRADE_REPORT_get, Swig_var_MatchType_CONFIRMED_TRADE_REPORT_set);
  SWIG_addvarlink(globals, "MatchType_AUTO_MATCH", Swig_var_MatchType_AUTO_MATCH_get, Swig_var_MatchType_AUTO_MATCH_set);
  SWIG_addvarlink(globals, "MatchType_ISSUING", Swig_var_MatchType_ISSUING_get, Swig_var_MatchType_ISSUING_set);
  SWIG_addvarlink(globals, "MatchType_SYSTEMATIC_INTERNALISER", Swig_var_MatchType_SYSTEMATIC_INTERNALISER_get, Swig_var_MatchType_SYSTEMATIC_INTERNALISER_set);
  SWIG_addvarlink(globals, "MatchType_AUTO_MATCH_LAST_LOOK", Swig_var_MatchType_AUTO_MATCH_LAST_LOOK_get, Swig_var_MatchType_AUTO_MATCH_LAST_LOOK_set);
  SWIG_addvarlink(globals, "MatchType_CROSS_AUCTION_LAST_LOOK", Swig_var_MatchType_CROSS_AUCTION_LAST_LOOK_get, Swig_var_MatchType_CROSS_AUCTION_LAST_LOOK_set);
  SWIG_addvarlink(globals, "OddLot_YES", Swig_var_OddLot_YES_get, Swig_var_OddLot_YES_set);
  SWIG_addvarlink(globals, "OddLot_NO", Swig_var_OddLot_NO_get, Swig_var_OddLot_NO_set);
  SWIG_addvarlink(globals, "ClearingInstruction_MANUAL_MODE", Swig_var_ClearingInstruction_MANUAL_MODE_get, Swig_var_ClearingInstruction_MANUAL_MODE_set);
  SWIG_addvarlink(globals, "ClearingInstruction_MULTILATERAL_NETTING", Swig_var_ClearingInstruction_MULTILATERAL_NETTING_get, Swig_var_ClearingInstruction_MULTILATERAL_NETTING_set);
  SWIG_addvarlink(globals, "ClearingInstruction_AUTOMATIC_POSTING_MODE", Swig_var_ClearingInstruction_AUTOMATIC_POSTING_MODE_get, Swig_var_ClearingInstruction_AUTOMATIC_POSTING_MODE_set);
  SWIG_addvarlink(globals, "ClearingInstruction_BILATERAL_NETTING_ONLY", Swig_var_ClearingInstruction_BILATERAL_NETTING_ONLY_get, Swig_var_ClearingInstruction_BILATERAL_NETTING_ONLY_set);
  SWIG_addvarlink(globals, "ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY", Swig_var_ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY_get, Swig_var_ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY_set);
  SWIG_addvarlink(globals, "ClearingInstruction_AUTOMATIC_GIVE_UP_MODE", Swig_var_ClearingInstruction_AUTOMATIC_GIVE_UP_MODE_get, Swig_var_ClearingInstruction_AUTOMATIC_GIVE_UP_MODE_set);
  SWIG_addvarlink(globals, "ClearingInstruction_SPECIAL_TRADE", Swig_var_ClearingInstruction_SPECIAL_TRADE_get, Swig_var_ClearingInstruction_SPECIAL_TRADE_set);
  SWIG_addvarlink(globals, "ClearingInstruction_EX_CLEARING", Swig_var_ClearingInstruction_EX_CLEARING_get, Swig_var_ClearingInstruction_EX_CLEARING_set);
  SWIG_addvarlink(globals, "ClearingInstruction_PROCESS_NORMALLY", Swig_var_ClearingInstruction_PROCESS_NORMALLY_get, Swig_var_ClearingInstruction_PROCESS_NORMALLY_set);
  SWIG_addvarlink(globals, "ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY", Swig_var_ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY_get, Swig_var_ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY_set);
  SWIG_addvarlink(globals, "ClearingInstruction_EXCLUDE_FROM_ALL_NETTING", Swig_var_ClearingInstruction_EXCLUDE_FROM_ALL_NETTING_get, Swig_var_ClearingInstruction_EXCLUDE_FROM_ALL_NETTING_set);
  SWIG_addvarlink(globals, "ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR", Swig_var_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR_get, Swig_var_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR_set);
  SWIG_addvarlink(globals, "ClearingInstruction_CUSTOMER_TRADE", Swig_var_ClearingInstruction_CUSTOMER_TRADE_get, Swig_var_ClearingInstruction_CUSTOMER_TRADE_set);
  SWIG_addvarlink(globals, "ClearingInstruction_SELF_CLEARING", Swig_var_ClearingInstruction_SELF_CLEARING_get, Swig_var_ClearingInstruction_SELF_CLEARING_set);
  SWIG_addvarlink(globals, "ClearingInstruction_BUY_IN", Swig_var_ClearingInstruction_BUY_IN_get, Swig_var_ClearingInstruction_BUY_IN_set);
  SWIG_addvarlink(globals, "AccountType_HOUSE_TRADER", Swig_var_AccountType_HOUSE_TRADER_get, Swig_var_AccountType_HOUSE_TRADER_set);
  SWIG_addvarlink(globals, "AccountType_HOUSE_TRADER_CROSS_MARGINED", Swig_var_AccountType_HOUSE_TRADER_CROSS_MARGINED_get, Swig_var_AccountType_HOUSE_TRADER_CROSS_MARGINED_set);
  SWIG_addvarlink(globals, "AccountType_CARRIED_NON_CUSTOMER_SIDE_CROSS_MARGINED", Swig_var_AccountType_CARRIED_NON_CUSTOMER_SIDE_CROSS_MARGINED_get, Swig_var_AccountType_CARRIED_NON_CUSTOMER_SIDE_CROSS_MARGINED_set);
  SWIG_addvarlink(globals, "AccountType_FLOOR_TRADER", Swig_var_AccountType_FLOOR_TRADER_get, Swig_var_AccountType_FLOOR_TRADER_set);
  SWIG_addvarlink(globals, "AccountType_CARRIED_NON_CUSTOMER_SIDE", Swig_var_AccountType_CARRIED_NON_CUSTOMER_SIDE_get, Swig_var_AccountType_CARRIED_NON_CUSTOMER_SIDE_set);
  SWIG_addvarlink(globals, "AccountType_CARRIED_CUSTOMER_SIDE", Swig_var_AccountType_CARRIED_CUSTOMER_SIDE_get, Swig_var_AccountType_CARRIED_CUSTOMER_SIDE_set);
  SWIG_addvarlink(globals, "AccountType_JOINT_BACK_OFFICE_ACCOUNT", Swig_var_AccountType_JOINT_BACK_OFFICE_ACCOUNT_get, Swig_var_AccountType_JOINT_BACK_OFFICE_ACCOUNT_set);
  SWIG_addvarlink(globals, "AccountType_EQUITIES_SPECIALIST", Swig_var_AccountType_EQUITIES_SPECIALIST_get, Swig_var_AccountType_EQUITIES_SPECIALIST_set);
  SWIG_addvarlink(globals, "AccountType_OPTIONS_MARKET_MAKER", Swig_var_AccountType_OPTIONS_MARKET_MAKER_get, Swig_var_AccountType_OPTIONS_MARKET_MAKER_set);
  SWIG_addvarlink(globals, "AccountType_OPTIONS_FIRM_ACCOUNT", Swig_var_AccountType_OPTIONS_FIRM_ACCOUNT_get, Swig_var_AccountType_OPTIONS_FIRM_ACCOUNT_set);
  SWIG_addvarlink(globals, "AccountType_ACCOUNT_CUSTOMER_NON_CUSTOMER_ORDERS", Swig_var_AccountType_ACCOUNT_CUSTOMER_NON_CUSTOMER_ORDERS_get, Swig_var_AccountType_ACCOUNT_CUSTOMER_NON_CUSTOMER_ORDERS_set);
  SWIG_addvarlink(globals, "AccountType_ACCOUNT_ORDERS_MULTIPLE_CUSTOMERS", Swig_var_AccountType_ACCOUNT_ORDERS_MULTIPLE_CUSTOMERS_get, Swig_var_AccountType_ACCOUNT_ORDERS_MULTIPLE_CUSTOMERS_set);
  SWIG_addvarlink(globals, "CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT", Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get, Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_set);
  SWIG_addvarlink(globals, "CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT", Swig_var_CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get, Swig_var_CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_set);
  SWIG_addvarlink(globals, "CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER", Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get, Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_set);
  SWIG_addvarlink(globals, "CustOrderCapacity_ALL_OTHER", Swig_var_CustOrderCapacity_ALL_OTHER_get, Swig_var_CustOrderCapacity_ALL_OTHER_set);
  SWIG_addvarlink(globals, "CustOrderCapacity_RETAIL_CUSTOMER", Swig_var_CustOrderCapacity_RETAIL_CUSTOMER_get, Swig_var_CustOrderCapacity_RETAIL_CUSTOMER_set);
  SWIG_addvarlink(globals, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY", Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_get, Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_set);
  SWIG_addvarlink(globals, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY", Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY_get, Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT", Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT_get, Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT_set);
  SWIG_addvarlink(globals, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_ACFI_CODE", Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_ACFI_CODE_get, Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_ACFI_CODE_set);
  SWIG_addvarlink(globals, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_TYPE", Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_TYPE_get, Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_TYPE_set);
  SWIG_addvarlink(globals, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION", Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION_get, Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION_set);
  SWIG_addvarlink(globals, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTY_ID", Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTY_ID_get, Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTY_ID_set);
  SWIG_addvarlink(globals, "MassStatusReqType_STATUS_FOR_ALL_ORDERS", Swig_var_MassStatusReqType_STATUS_FOR_ALL_ORDERS_get, Swig_var_MassStatusReqType_STATUS_FOR_ALL_ORDERS_set);
  SWIG_addvarlink(globals, "MassStatusReqType_STATUS_FOR_SECURITY_ISSUER", Swig_var_MassStatusReqType_STATUS_FOR_SECURITY_ISSUER_get, Swig_var_MassStatusReqType_STATUS_FOR_SECURITY_ISSUER_set);
  SWIG_addvarlink(globals, "MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY", Swig_var_MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "DayBookingInst_AUTO", Swig_var_DayBookingInst_AUTO_get, Swig_var_DayBookingInst_AUTO_set);
  SWIG_addvarlink(globals, "DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING", Swig_var_DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_get, Swig_var_DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_set);
  SWIG_addvarlink(globals, "DayBookingInst_ACCUMULATE", Swig_var_DayBookingInst_ACCUMULATE_get, Swig_var_DayBookingInst_ACCUMULATE_set);
  SWIG_addvarlink(globals, "BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER", Swig_var_BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_get, Swig_var_BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_set);
  SWIG_addvarlink(globals, "BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL", Swig_var_BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_get, Swig_var_BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_set);
  SWIG_addvarlink(globals, "BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT", Swig_var_BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT_get, Swig_var_BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT_set);
  SWIG_addvarlink(globals, "PreallocMethod_PRO_RATA", Swig_var_PreallocMethod_PRO_RATA_get, Swig_var_PreallocMethod_PRO_RATA_set);
  SWIG_addvarlink(globals, "PreallocMethod_DO_NOT_PRO_RATA", Swig_var_PreallocMethod_DO_NOT_PRO_RATA_get, Swig_var_PreallocMethod_DO_NOT_PRO_RATA_set);
  SWIG_addvarlink(globals, "TradingSessionSubID_PRE_TRADING", Swig_var_TradingSessionSubID_PRE_TRADING_get, Swig_var_TradingSessionSubID_PRE_TRADING_set);
  SWIG_addvarlink(globals, "TradingSessionSubID_OPENING_OR_OPENING_AUCTION", Swig_var_TradingSessionSubID_OPENING_OR_OPENING_AUCTION_get, Swig_var_TradingSessionSubID_OPENING_OR_OPENING_AUCTION_set);
  SWIG_addvarlink(globals, "TradingSessionSubID_CONTINUOUS", Swig_var_TradingSessionSubID_CONTINUOUS_get, Swig_var_TradingSessionSubID_CONTINUOUS_set);
  SWIG_addvarlink(globals, "TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION", Swig_var_TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_get, Swig_var_TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_set);
  SWIG_addvarlink(globals, "TradingSessionSubID_POST_TRADING", Swig_var_TradingSessionSubID_POST_TRADING_get, Swig_var_TradingSessionSubID_POST_TRADING_set);
  SWIG_addvarlink(globals, "TradingSessionSubID_INTRADAY_AUCTION", Swig_var_TradingSessionSubID_INTRADAY_AUCTION_get, Swig_var_TradingSessionSubID_INTRADAY_AUCTION_set);
  SWIG_addvarlink(globals, "TradingSessionSubID_QUIESCENT", Swig_var_TradingSessionSubID_QUIESCENT_get, Swig_var_TradingSessionSubID_QUIESCENT_set);
  SWIG_addvarlink(globals, "TradingSessionSubID_SCHEDULED_INTRADAY_AUCTION", Swig_var_TradingSessionSubID_SCHEDULED_INTRADAY_AUCTION_get, Swig_var_TradingSessionSubID_SCHEDULED_INTRADAY_AUCTION_set);
  SWIG_addvarlink(globals, "TradingSessionSubID_ANY_AUCTION", Swig_var_TradingSessionSubID_ANY_AUCTION_get, Swig_var_TradingSessionSubID_ANY_AUCTION_set);
  SWIG_addvarlink(globals, "TradingSessionSubID_UNSCHEDULED_INTRADAY_AUCTION", Swig_var_TradingSessionSubID_UNSCHEDULED_INTRADAY_AUCTION_get, Swig_var_TradingSessionSubID_UNSCHEDULED_INTRADAY_AUCTION_set);
  SWIG_addvarlink(globals, "TradingSessionSubID_OUT_OF_MAIN_SESSION_TRADING", Swig_var_TradingSessionSubID_OUT_OF_MAIN_SESSION_TRADING_get, Swig_var_TradingSessionSubID_OUT_OF_MAIN_SESSION_TRADING_set);
  SWIG_addvarlink(globals, "TradingSessionSubID_PRIVATE_AUCTION", Swig_var_TradingSessionSubID_PRIVATE_AUCTION_get, Swig_var_TradingSessionSubID_PRIVATE_AUCTION_set);
  SWIG_addvarlink(globals, "TradingSessionSubID_PUBLIC_AUCTION", Swig_var_TradingSessionSubID_PUBLIC_AUCTION_get, Swig_var_TradingSessionSubID_PUBLIC_AUCTION_set);
  SWIG_addvarlink(globals, "TradingSessionSubID_GROUP_AUCTION", Swig_var_TradingSessionSubID_GROUP_AUCTION_get, Swig_var_TradingSessionSubID_GROUP_AUCTION_set);
  SWIG_addvarlink(globals, "AllocType_BUYSIDE_READY_TO_BOOK", Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_get, Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_set);
  SWIG_addvarlink(globals, "AllocType_PRELIMINARY", Swig_var_AllocType_PRELIMINARY_get, Swig_var_AllocType_PRELIMINARY_set);
  SWIG_addvarlink(globals, "AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY", Swig_var_AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get, Swig_var_AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY_set);
  SWIG_addvarlink(globals, "AllocType_READY_TO_BOOK", Swig_var_AllocType_READY_TO_BOOK_get, Swig_var_AllocType_READY_TO_BOOK_set);
  SWIG_addvarlink(globals, "AllocType_CALCULATED", Swig_var_AllocType_CALCULATED_get, Swig_var_AllocType_CALCULATED_set);
  SWIG_addvarlink(globals, "AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY", Swig_var_AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get, Swig_var_AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_set);
  SWIG_addvarlink(globals, "AllocType_WAREHOUSE_INSTRUCTION", Swig_var_AllocType_WAREHOUSE_INSTRUCTION_get, Swig_var_AllocType_WAREHOUSE_INSTRUCTION_set);
  SWIG_addvarlink(globals, "AllocType_REQUEST_TO_INTERMEDIARY", Swig_var_AllocType_REQUEST_TO_INTERMEDIARY_get, Swig_var_AllocType_REQUEST_TO_INTERMEDIARY_set);
  SWIG_addvarlink(globals, "AllocType_ACCEPT", Swig_var_AllocType_ACCEPT_get, Swig_var_AllocType_ACCEPT_set);
  SWIG_addvarlink(globals, "AllocType_REJECT", Swig_var_AllocType_REJECT_get, Swig_var_AllocType_REJECT_set);
  SWIG_addvarlink(globals, "AllocType_ACCEPT_PENDING", Swig_var_AllocType_ACCEPT_PENDING_get, Swig_var_AllocType_ACCEPT_PENDING_set);
  SWIG_addvarlink(globals, "AllocType_INCOMPLETE_GROUP", Swig_var_AllocType_INCOMPLETE_GROUP_get, Swig_var_AllocType_INCOMPLETE_GROUP_set);
  SWIG_addvarlink(globals, "AllocType_COMPLETE_GROUP", Swig_var_AllocType_COMPLETE_GROUP_get, Swig_var_AllocType_COMPLETE_GROUP_set);
  SWIG_addvarlink(globals, "AllocType_REVERSAL_PENDING", Swig_var_AllocType_REVERSAL_PENDING_get, Swig_var_AllocType_REVERSAL_PENDING_set);
  SWIG_addvarlink(globals, "AllocType_REOPEN_GROUP", Swig_var_AllocType_REOPEN_GROUP_get, Swig_var_AllocType_REOPEN_GROUP_set);
  SWIG_addvarlink(globals, "AllocType_CANCEL_GROUP", Swig_var_AllocType_CANCEL_GROUP_get, Swig_var_AllocType_CANCEL_GROUP_set);
  SWIG_addvarlink(globals, "AllocType_GIVEUP", Swig_var_AllocType_GIVEUP_get, Swig_var_AllocType_GIVEUP_set);
  SWIG_addvarlink(globals, "AllocType_TAKEUP", Swig_var_AllocType_TAKEUP_get, Swig_var_AllocType_TAKEUP_set);
  SWIG_addvarlink(globals, "AllocType_REFUSE_TAKEUP", Swig_var_AllocType_REFUSE_TAKEUP_get, Swig_var_AllocType_REFUSE_TAKEUP_set);
  SWIG_addvarlink(globals, "AllocType_INITIATE_REVERSAL", Swig_var_AllocType_INITIATE_REVERSAL_get, Swig_var_AllocType_INITIATE_REVERSAL_set);
  SWIG_addvarlink(globals, "AllocType_REVERSE", Swig_var_AllocType_REVERSE_get, Swig_var_AllocType_REVERSE_set);
  SWIG_addvarlink(globals, "AllocType_REFUSE_REVERSAL", Swig_var_AllocType_REFUSE_REVERSAL_get, Swig_var_AllocType_REFUSE_REVERSAL_set);
  SWIG_addvarlink(globals, "AllocType_SUB_ALLOCATION_GIVEUP", Swig_var_AllocType_SUB_ALLOCATION_GIVEUP_get, Swig_var_AllocType_SUB_ALLOCATION_GIVEUP_set);
  SWIG_addvarlink(globals, "AllocType_APPROVE_GIVEUP", Swig_var_AllocType_APPROVE_GIVEUP_get, Swig_var_AllocType_APPROVE_GIVEUP_set);
  SWIG_addvarlink(globals, "AllocType_APPROVE_TAKEUP", Swig_var_AllocType_APPROVE_TAKEUP_get, Swig_var_AllocType_APPROVE_TAKEUP_set);
  SWIG_addvarlink(globals, "AllocType_NOTIONAL_VALUE_AVERAGE_PX_GROUP_ALLOC", Swig_var_AllocType_NOTIONAL_VALUE_AVERAGE_PX_GROUP_ALLOC_get, Swig_var_AllocType_NOTIONAL_VALUE_AVERAGE_PX_GROUP_ALLOC_set);
  SWIG_addvarlink(globals, "ClearingFeeIndicator_FIRMS106_H_AND106_J", Swig_var_ClearingFeeIndicator_FIRMS106_H_AND106_J_get, Swig_var_ClearingFeeIndicator_FIRMS106_H_AND106_J_set);
  SWIG_addvarlink(globals, "ClearingFeeIndicator_FIFTH_YEAR_DELEGATE", Swig_var_ClearingFeeIndicator_FIFTH_YEAR_DELEGATE_get, Swig_var_ClearingFeeIndicator_FIFTH_YEAR_DELEGATE_set);
  SWIG_addvarlink(globals, "ClearingFeeIndicator_FOURTH_YEAR_DELEGATE", Swig_var_ClearingFeeIndicator_FOURTH_YEAR_DELEGATE_get, Swig_var_ClearingFeeIndicator_FOURTH_YEAR_DELEGATE_set);
  SWIG_addvarlink(globals, "ClearingFeeIndicator_THIRD_YEAR_DELEGATE", Swig_var_ClearingFeeIndicator_THIRD_YEAR_DELEGATE_get, Swig_var_ClearingFeeIndicator_THIRD_YEAR_DELEGATE_set);
  SWIG_addvarlink(globals, "ClearingFeeIndicator_SECOND_YEAR_DELEGATE", Swig_var_ClearingFeeIndicator_SECOND_YEAR_DELEGATE_get, Swig_var_ClearingFeeIndicator_SECOND_YEAR_DELEGATE_set);
  SWIG_addvarlink(globals, "ClearingFeeIndicator_FIRST_YEAR_DELEGATE", Swig_var_ClearingFeeIndicator_FIRST_YEAR_DELEGATE_get, Swig_var_ClearingFeeIndicator_FIRST_YEAR_DELEGATE_set);
  SWIG_addvarlink(globals, "ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES", Swig_var_ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_get, Swig_var_ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_set);
  SWIG_addvarlink(globals, "ClearingFeeIndicator_GIM", Swig_var_ClearingFeeIndicator_GIM_get, Swig_var_ClearingFeeIndicator_GIM_set);
  SWIG_addvarlink(globals, "ClearingFeeIndicator_SIXTH_YEAR_DELEGATE", Swig_var_ClearingFeeIndicator_SIXTH_YEAR_DELEGATE_get, Swig_var_ClearingFeeIndicator_SIXTH_YEAR_DELEGATE_set);
  SWIG_addvarlink(globals, "ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER", Swig_var_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_get, Swig_var_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_set);
  SWIG_addvarlink(globals, "ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER", Swig_var_ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER_get, Swig_var_ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER_set);
  SWIG_addvarlink(globals, "ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER", Swig_var_ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_get, Swig_var_ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_set);
  SWIG_addvarlink(globals, "ClearingFeeIndicator_CBOE_MEMBER", Swig_var_ClearingFeeIndicator_CBOE_MEMBER_get, Swig_var_ClearingFeeIndicator_CBOE_MEMBER_set);
  SWIG_addvarlink(globals, "ClearingFeeIndicator_LESSEE106_F_EMPLOYEES", Swig_var_ClearingFeeIndicator_LESSEE106_F_EMPLOYEES_get, Swig_var_ClearingFeeIndicator_LESSEE106_F_EMPLOYEES_set);
  SWIG_addvarlink(globals, "WorkingIndicator_NO", Swig_var_WorkingIndicator_NO_get, Swig_var_WorkingIndicator_NO_set);
  SWIG_addvarlink(globals, "WorkingIndicator_YES", Swig_var_WorkingIndicator_YES_get, Swig_var_WorkingIndicator_YES_set);
  SWIG_addvarlink(globals, "PriorityIndicator_PRIORITY_UNCHANGED", Swig_var_PriorityIndicator_PRIORITY_UNCHANGED_get, Swig_var_PriorityIndicator_PRIORITY_UNCHANGED_set);
  SWIG_addvarlink(globals, "PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE", Swig_var_PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE_get, Swig_var_PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE_set);
  SWIG_addvarlink(globals, "LegalConfirm_YES", Swig_var_LegalConfirm_YES_get, Swig_var_LegalConfirm_YES_set);
  SWIG_addvarlink(globals, "LegalConfirm_NO", Swig_var_LegalConfirm_NO_get, Swig_var_LegalConfirm_NO_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_UNKNOWN_SYMBOL", Swig_var_QuoteRequestRejectReason_UNKNOWN_SYMBOL_get, Swig_var_QuoteRequestRejectReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_EXCHANGE", Swig_var_QuoteRequestRejectReason_EXCHANGE_get, Swig_var_QuoteRequestRejectReason_EXCHANGE_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT", Swig_var_QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get, Swig_var_QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_TOO_LATE_TO_ENTER", Swig_var_QuoteRequestRejectReason_TOO_LATE_TO_ENTER_get, Swig_var_QuoteRequestRejectReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_INVALID_PRICE", Swig_var_QuoteRequestRejectReason_INVALID_PRICE_get, Swig_var_QuoteRequestRejectReason_INVALID_PRICE_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE", Swig_var_QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE_get, Swig_var_QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY", Swig_var_QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY_get, Swig_var_QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT", Swig_var_QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT_get, Swig_var_QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_NO_INVENTORY", Swig_var_QuoteRequestRejectReason_NO_INVENTORY_get, Swig_var_QuoteRequestRejectReason_NO_INVENTORY_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_PASS", Swig_var_QuoteRequestRejectReason_PASS_get, Swig_var_QuoteRequestRejectReason_PASS_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_OTHER", Swig_var_QuoteRequestRejectReason_OTHER_get, Swig_var_QuoteRequestRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_INSUFFICIENT_CREDIT", Swig_var_QuoteRequestRejectReason_INSUFFICIENT_CREDIT_get, Swig_var_QuoteRequestRejectReason_INSUFFICIENT_CREDIT_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_EXCEEDED_CLIP_SIZE_LIMIT", Swig_var_QuoteRequestRejectReason_EXCEEDED_CLIP_SIZE_LIMIT_get, Swig_var_QuoteRequestRejectReason_EXCEEDED_CLIP_SIZE_LIMIT_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT", Swig_var_QuoteRequestRejectReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT_get, Swig_var_QuoteRequestRejectReason_EXCEEDED_MAX_NOTIONAL_ORDER_AMT_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_EXCEEDED_DV01_PV01_LIMIT", Swig_var_QuoteRequestRejectReason_EXCEEDED_DV01_PV01_LIMIT_get, Swig_var_QuoteRequestRejectReason_EXCEEDED_DV01_PV01_LIMIT_set);
  SWIG_addvarlink(globals, "QuoteRequestRejectReason_EXCEEDED_CS01_LIMIT", Swig_var_QuoteRequestRejectReason_EXCEEDED_CS01_LIMIT_get, Swig_var_QuoteRequestRejectReason_EXCEEDED_CS01_LIMIT_set);
  SWIG_addvarlink(globals, "SettlType_REGULAR", Swig_var_SettlType_REGULAR_get, Swig_var_SettlType_REGULAR_set);
  SWIG_addvarlink(globals, "SettlType_CASH", Swig_var_SettlType_CASH_get, Swig_var_SettlType_CASH_set);
  SWIG_addvarlink(globals, "SettlType_NEXT_DAY", Swig_var_SettlType_NEXT_DAY_get, Swig_var_SettlType_NEXT_DAY_set);
  SWIG_addvarlink(globals, "SettlType_T_PLUS2", Swig_var_SettlType_T_PLUS2_get, Swig_var_SettlType_T_PLUS2_set);
  SWIG_addvarlink(globals, "SettlType_T_PLUS3", Swig_var_SettlType_T_PLUS3_get, Swig_var_SettlType_T_PLUS3_set);
  SWIG_addvarlink(globals, "SettlType_T_PLUS4", Swig_var_SettlType_T_PLUS4_get, Swig_var_SettlType_T_PLUS4_set);
  SWIG_addvarlink(globals, "SettlType_FUTURE", Swig_var_SettlType_FUTURE_get, Swig_var_SettlType_FUTURE_set);
  SWIG_addvarlink(globals, "SettlType_WHEN_AND_IF_ISSUED", Swig_var_SettlType_WHEN_AND_IF_ISSUED_get, Swig_var_SettlType_WHEN_AND_IF_ISSUED_set);
  SWIG_addvarlink(globals, "SettlType_SELLERS_OPTION", Swig_var_SettlType_SELLERS_OPTION_get, Swig_var_SettlType_SELLERS_OPTION_set);
  SWIG_addvarlink(globals, "SettlType_T_PLUS5", Swig_var_SettlType_T_PLUS5_get, Swig_var_SettlType_T_PLUS5_set);
  SWIG_addvarlink(globals, "SettlType_BROKEN_DATE", Swig_var_SettlType_BROKEN_DATE_get, Swig_var_SettlType_BROKEN_DATE_set);
  SWIG_addvarlink(globals, "SettlType_FX_SPOT_NEXT_SETTLEMENT", Swig_var_SettlType_FX_SPOT_NEXT_SETTLEMENT_get, Swig_var_SettlType_FX_SPOT_NEXT_SETTLEMENT_set);
  SWIG_addvarlink(globals, "OpenCloseSettlFlag_DAILY_OPEN", Swig_var_OpenCloseSettlFlag_DAILY_OPEN_get, Swig_var_OpenCloseSettlFlag_DAILY_OPEN_set);
  SWIG_addvarlink(globals, "OpenCloseSettlFlag_SESSION_OPEN", Swig_var_OpenCloseSettlFlag_SESSION_OPEN_get, Swig_var_OpenCloseSettlFlag_SESSION_OPEN_set);
  SWIG_addvarlink(globals, "OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY", Swig_var_OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY_get, Swig_var_OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY_set);
  SWIG_addvarlink(globals, "OpenCloseSettlFlag_EXPECTED_ENTRY", Swig_var_OpenCloseSettlFlag_EXPECTED_ENTRY_get, Swig_var_OpenCloseSettlFlag_EXPECTED_ENTRY_set);
  SWIG_addvarlink(globals, "OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY", Swig_var_OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_get, Swig_var_OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_set);
  SWIG_addvarlink(globals, "OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE", Swig_var_OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE_get, Swig_var_OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE_set);
  SWIG_addvarlink(globals, "BidTradeType_RISK_TRADE", Swig_var_BidTradeType_RISK_TRADE_get, Swig_var_BidTradeType_RISK_TRADE_set);
  SWIG_addvarlink(globals, "BidTradeType_VWAP_GUARANTEE", Swig_var_BidTradeType_VWAP_GUARANTEE_get, Swig_var_BidTradeType_VWAP_GUARANTEE_set);
  SWIG_addvarlink(globals, "BidTradeType_AGENCY", Swig_var_BidTradeType_AGENCY_get, Swig_var_BidTradeType_AGENCY_set);
  SWIG_addvarlink(globals, "BidTradeType_GUARANTEED_CLOSE", Swig_var_BidTradeType_GUARANTEED_CLOSE_get, Swig_var_BidTradeType_GUARANTEED_CLOSE_set);
  SWIG_addvarlink(globals, "AcctIDSource_BIC", Swig_var_AcctIDSource_BIC_get, Swig_var_AcctIDSource_BIC_set);
  SWIG_addvarlink(globals, "AcctIDSource_SID_CODE", Swig_var_AcctIDSource_SID_CODE_get, Swig_var_AcctIDSource_SID_CODE_set);
  SWIG_addvarlink(globals, "AcctIDSource_TFM", Swig_var_AcctIDSource_TFM_get, Swig_var_AcctIDSource_TFM_set);
  SWIG_addvarlink(globals, "AcctIDSource_OMGEO", Swig_var_AcctIDSource_OMGEO_get, Swig_var_AcctIDSource_OMGEO_set);
  SWIG_addvarlink(globals, "AcctIDSource_DTCC_CODE", Swig_var_AcctIDSource_DTCC_CODE_get, Swig_var_AcctIDSource_DTCC_CODE_set);
  SWIG_addvarlink(globals, "AcctIDSource_OTHER", Swig_var_AcctIDSource_OTHER_get, Swig_var_AcctIDSource_OTHER_set);
  SWIG_addvarlink(globals, "AcctIDSource_SPSAID", Swig_var_AcctIDSource_SPSAID_get, Swig_var_AcctIDSource_SPSAID_set);
  SWIG_addvarlink(globals, "ConfirmStatus_RECEIVED", Swig_var_ConfirmStatus_RECEIVED_get, Swig_var_ConfirmStatus_RECEIVED_set);
  SWIG_addvarlink(globals, "ConfirmStatus_MISMATCHED_ACCOUNT", Swig_var_ConfirmStatus_MISMATCHED_ACCOUNT_get, Swig_var_ConfirmStatus_MISMATCHED_ACCOUNT_set);
  SWIG_addvarlink(globals, "ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS", Swig_var_ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS_get, Swig_var_ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS_set);
  SWIG_addvarlink(globals, "ConfirmStatus_CONFIRMED", Swig_var_ConfirmStatus_CONFIRMED_get, Swig_var_ConfirmStatus_CONFIRMED_set);
  SWIG_addvarlink(globals, "ConfirmStatus_REQUEST_REJECTED", Swig_var_ConfirmStatus_REQUEST_REJECTED_get, Swig_var_ConfirmStatus_REQUEST_REJECTED_set);
  SWIG_addvarlink(globals, "ConfirmTransType_NEW", Swig_var_ConfirmTransType_NEW_get, Swig_var_ConfirmTransType_NEW_set);
  SWIG_addvarlink(globals, "ConfirmTransType_REPLACE", Swig_var_ConfirmTransType_REPLACE_get, Swig_var_ConfirmTransType_REPLACE_set);
  SWIG_addvarlink(globals, "ConfirmTransType_CANCEL", Swig_var_ConfirmTransType_CANCEL_get, Swig_var_ConfirmTransType_CANCEL_set);
  SWIG_addvarlink(globals, "DeliveryForm_BOOK_ENTRY", Swig_var_DeliveryForm_BOOK_ENTRY_get, Swig_var_DeliveryForm_BOOK_ENTRY_set);
  SWIG_addvarlink(globals, "DeliveryForm_BEARER", Swig_var_DeliveryForm_BEARER_get, Swig_var_DeliveryForm_BEARER_set);
  SWIG_addvarlink(globals, "LegSwapType_PAR_FOR_PAR", Swig_var_LegSwapType_PAR_FOR_PAR_get, Swig_var_LegSwapType_PAR_FOR_PAR_set);
  SWIG_addvarlink(globals, "LegSwapType_MODIFIED_DURATION", Swig_var_LegSwapType_MODIFIED_DURATION_get, Swig_var_LegSwapType_MODIFIED_DURATION_set);
  SWIG_addvarlink(globals, "LegSwapType_RISK", Swig_var_LegSwapType_RISK_get, Swig_var_LegSwapType_RISK_set);
  SWIG_addvarlink(globals, "LegSwapType_PROCEEDS", Swig_var_LegSwapType_PROCEEDS_get, Swig_var_LegSwapType_PROCEEDS_set);
  SWIG_addvarlink(globals, "QuotePriceType_PERCENT", Swig_var_QuotePriceType_PERCENT_get, Swig_var_QuotePriceType_PERCENT_set);
  SWIG_addvarlink(globals, "QuotePriceType_PER_SHARE", Swig_var_QuotePriceType_PER_SHARE_get, Swig_var_QuotePriceType_PER_SHARE_set);
  SWIG_addvarlink(globals, "QuotePriceType_FIXED_AMOUNT", Swig_var_QuotePriceType_FIXED_AMOUNT_get, Swig_var_QuotePriceType_FIXED_AMOUNT_set);
  SWIG_addvarlink(globals, "QuotePriceType_DISCOUNT", Swig_var_QuotePriceType_DISCOUNT_get, Swig_var_QuotePriceType_DISCOUNT_set);
  SWIG_addvarlink(globals, "QuotePriceType_PREMIUM", Swig_var_QuotePriceType_PREMIUM_get, Swig_var_QuotePriceType_PREMIUM_set);
  SWIG_addvarlink(globals, "QuotePriceType_SPREAD", Swig_var_QuotePriceType_SPREAD_get, Swig_var_QuotePriceType_SPREAD_set);
  SWIG_addvarlink(globals, "QuotePriceType_TED_PRICE", Swig_var_QuotePriceType_TED_PRICE_get, Swig_var_QuotePriceType_TED_PRICE_set);
  SWIG_addvarlink(globals, "QuotePriceType_TED_YIELD", Swig_var_QuotePriceType_TED_YIELD_get, Swig_var_QuotePriceType_TED_YIELD_set);
  SWIG_addvarlink(globals, "QuotePriceType_YIELD_SPREAD", Swig_var_QuotePriceType_YIELD_SPREAD_get, Swig_var_QuotePriceType_YIELD_SPREAD_set);
  SWIG_addvarlink(globals, "QuotePriceType_YIELD", Swig_var_QuotePriceType_YIELD_get, Swig_var_QuotePriceType_YIELD_set);
  SWIG_addvarlink(globals, "QuotePriceType_PRICE_SPREAD", Swig_var_QuotePriceType_PRICE_SPREAD_get, Swig_var_QuotePriceType_PRICE_SPREAD_set);
  SWIG_addvarlink(globals, "QuotePriceType_PRODUCT_TICKS_IN_HALVES", Swig_var_QuotePriceType_PRODUCT_TICKS_IN_HALVES_get, Swig_var_QuotePriceType_PRODUCT_TICKS_IN_HALVES_set);
  SWIG_addvarlink(globals, "QuotePriceType_PRODUCT_TICKS_IN_FOURTHS", Swig_var_QuotePriceType_PRODUCT_TICKS_IN_FOURTHS_get, Swig_var_QuotePriceType_PRODUCT_TICKS_IN_FOURTHS_set);
  SWIG_addvarlink(globals, "QuotePriceType_PRODUCT_TICKS_IN_EIGHTHS", Swig_var_QuotePriceType_PRODUCT_TICKS_IN_EIGHTHS_get, Swig_var_QuotePriceType_PRODUCT_TICKS_IN_EIGHTHS_set);
  SWIG_addvarlink(globals, "QuotePriceType_PRODUCT_TICKS_IN_SIXTEENTHS", Swig_var_QuotePriceType_PRODUCT_TICKS_IN_SIXTEENTHS_get, Swig_var_QuotePriceType_PRODUCT_TICKS_IN_SIXTEENTHS_set);
  SWIG_addvarlink(globals, "QuotePriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS", Swig_var_QuotePriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_get, Swig_var_QuotePriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_set);
  SWIG_addvarlink(globals, "QuotePriceType_PRODUCT_TICKS_IN_SIXTY_FOURTHS", Swig_var_QuotePriceType_PRODUCT_TICKS_IN_SIXTY_FOURTHS_get, Swig_var_QuotePriceType_PRODUCT_TICKS_IN_SIXTY_FOURTHS_set);
  SWIG_addvarlink(globals, "QuotePriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTHS", Swig_var_QuotePriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTHS_get, Swig_var_QuotePriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTHS_set);
  SWIG_addvarlink(globals, "QuotePriceType_NORMAL_RATE_REPRESENTATION", Swig_var_QuotePriceType_NORMAL_RATE_REPRESENTATION_get, Swig_var_QuotePriceType_NORMAL_RATE_REPRESENTATION_set);
  SWIG_addvarlink(globals, "QuotePriceType_INVERSE_RATE_REPRESENTATION", Swig_var_QuotePriceType_INVERSE_RATE_REPRESENTATION_get, Swig_var_QuotePriceType_INVERSE_RATE_REPRESENTATION_set);
  SWIG_addvarlink(globals, "QuotePriceType_BASIS_POINTS", Swig_var_QuotePriceType_BASIS_POINTS_get, Swig_var_QuotePriceType_BASIS_POINTS_set);
  SWIG_addvarlink(globals, "QuotePriceType_UP_FRONT_POINTS", Swig_var_QuotePriceType_UP_FRONT_POINTS_get, Swig_var_QuotePriceType_UP_FRONT_POINTS_set);
  SWIG_addvarlink(globals, "QuotePriceType_INTEREST_RATE", Swig_var_QuotePriceType_INTEREST_RATE_get, Swig_var_QuotePriceType_INTEREST_RATE_set);
  SWIG_addvarlink(globals, "QuotePriceType_PERCENTAGE_OF_NOTIONAL", Swig_var_QuotePriceType_PERCENTAGE_OF_NOTIONAL_get, Swig_var_QuotePriceType_PERCENTAGE_OF_NOTIONAL_set);
  SWIG_addvarlink(globals, "QuoteRespType_HIT", Swig_var_QuoteRespType_HIT_get, Swig_var_QuoteRespType_HIT_set);
  SWIG_addvarlink(globals, "QuoteRespType_COUNTER", Swig_var_QuoteRespType_COUNTER_get, Swig_var_QuoteRespType_COUNTER_set);
  SWIG_addvarlink(globals, "QuoteRespType_EXPIRED", Swig_var_QuoteRespType_EXPIRED_get, Swig_var_QuoteRespType_EXPIRED_set);
  SWIG_addvarlink(globals, "QuoteRespType_COVER", Swig_var_QuoteRespType_COVER_get, Swig_var_QuoteRespType_COVER_set);
  SWIG_addvarlink(globals, "QuoteRespType_DONE_AWAY", Swig_var_QuoteRespType_DONE_AWAY_get, Swig_var_QuoteRespType_DONE_AWAY_set);
  SWIG_addvarlink(globals, "QuoteRespType_PASS", Swig_var_QuoteRespType_PASS_get, Swig_var_QuoteRespType_PASS_set);
  SWIG_addvarlink(globals, "QuoteRespType_END_TRADE", Swig_var_QuoteRespType_END_TRADE_get, Swig_var_QuoteRespType_END_TRADE_set);
  SWIG_addvarlink(globals, "QuoteRespType_TIMED_OUT", Swig_var_QuoteRespType_TIMED_OUT_get, Swig_var_QuoteRespType_TIMED_OUT_set);
  SWIG_addvarlink(globals, "QuoteRespType_TIED", Swig_var_QuoteRespType_TIED_get, Swig_var_QuoteRespType_TIED_set);
  SWIG_addvarlink(globals, "QuoteRespType_TIED_COVER", Swig_var_QuoteRespType_TIED_COVER_get, Swig_var_QuoteRespType_TIED_COVER_set);
  SWIG_addvarlink(globals, "QuoteRespType_ACCEPT", Swig_var_QuoteRespType_ACCEPT_get, Swig_var_QuoteRespType_ACCEPT_set);
  SWIG_addvarlink(globals, "QuoteRespType_TERMINATE_CONTRACT", Swig_var_QuoteRespType_TERMINATE_CONTRACT_get, Swig_var_QuoteRespType_TERMINATE_CONTRACT_set);
  SWIG_addvarlink(globals, "PosType_TRANSACTION_QUANTITY", Swig_var_PosType_TRANSACTION_QUANTITY_get, Swig_var_PosType_TRANSACTION_QUANTITY_set);
  SWIG_addvarlink(globals, "PosType_INTRA_SPREAD_QTY", Swig_var_PosType_INTRA_SPREAD_QTY_get, Swig_var_PosType_INTRA_SPREAD_QTY_set);
  SWIG_addvarlink(globals, "PosType_INTER_SPREAD_QTY", Swig_var_PosType_INTER_SPREAD_QTY_get, Swig_var_PosType_INTER_SPREAD_QTY_set);
  SWIG_addvarlink(globals, "PosType_END_OF_DAY_QTY", Swig_var_PosType_END_OF_DAY_QTY_get, Swig_var_PosType_END_OF_DAY_QTY_set);
  SWIG_addvarlink(globals, "PosType_START_OF_DAY_QTY", Swig_var_PosType_START_OF_DAY_QTY_get, Swig_var_PosType_START_OF_DAY_QTY_set);
  SWIG_addvarlink(globals, "PosType_OPTION_EXERCISE_QTY", Swig_var_PosType_OPTION_EXERCISE_QTY_get, Swig_var_PosType_OPTION_EXERCISE_QTY_set);
  SWIG_addvarlink(globals, "PosType_OPTION_ASSIGNMENT", Swig_var_PosType_OPTION_ASSIGNMENT_get, Swig_var_PosType_OPTION_ASSIGNMENT_set);
  SWIG_addvarlink(globals, "PosType_TRANSACTION_FROM_EXERCISE", Swig_var_PosType_TRANSACTION_FROM_EXERCISE_get, Swig_var_PosType_TRANSACTION_FROM_EXERCISE_set);
  SWIG_addvarlink(globals, "PosType_TRANSACTION_FROM_ASSIGNMENT", Swig_var_PosType_TRANSACTION_FROM_ASSIGNMENT_get, Swig_var_PosType_TRANSACTION_FROM_ASSIGNMENT_set);
  SWIG_addvarlink(globals, "PosType_PIT_TRADE_QTY", Swig_var_PosType_PIT_TRADE_QTY_get, Swig_var_PosType_PIT_TRADE_QTY_set);
  SWIG_addvarlink(globals, "PosType_TRANSFER_TRADE_QTY", Swig_var_PosType_TRANSFER_TRADE_QTY_get, Swig_var_PosType_TRANSFER_TRADE_QTY_set);
  SWIG_addvarlink(globals, "PosType_ELECTRONIC_TRADE_QTY", Swig_var_PosType_ELECTRONIC_TRADE_QTY_get, Swig_var_PosType_ELECTRONIC_TRADE_QTY_set);
  SWIG_addvarlink(globals, "PosType_ALLOCATION_TRADE_QTY", Swig_var_PosType_ALLOCATION_TRADE_QTY_get, Swig_var_PosType_ALLOCATION_TRADE_QTY_set);
  SWIG_addvarlink(globals, "PosType_ADJUSTMENT_QTY", Swig_var_PosType_ADJUSTMENT_QTY_get, Swig_var_PosType_ADJUSTMENT_QTY_set);
  SWIG_addvarlink(globals, "PosType_AS_OF_TRADE_QTY", Swig_var_PosType_AS_OF_TRADE_QTY_get, Swig_var_PosType_AS_OF_TRADE_QTY_set);
  SWIG_addvarlink(globals, "PosType_DELIVERY_QTY", Swig_var_PosType_DELIVERY_QTY_get, Swig_var_PosType_DELIVERY_QTY_set);
  SWIG_addvarlink(globals, "PosType_TOTAL_TRANSACTION_QTY", Swig_var_PosType_TOTAL_TRANSACTION_QTY_get, Swig_var_PosType_TOTAL_TRANSACTION_QTY_set);
  SWIG_addvarlink(globals, "PosType_CROSS_MARGIN_QTY", Swig_var_PosType_CROSS_MARGIN_QTY_get, Swig_var_PosType_CROSS_MARGIN_QTY_set);
  SWIG_addvarlink(globals, "PosType_INTEGRAL_SPLIT", Swig_var_PosType_INTEGRAL_SPLIT_get, Swig_var_PosType_INTEGRAL_SPLIT_set);
  SWIG_addvarlink(globals, "PosType_RECEIVE_QUANTITY", Swig_var_PosType_RECEIVE_QUANTITY_get, Swig_var_PosType_RECEIVE_QUANTITY_set);
  SWIG_addvarlink(globals, "PosType_CORPORATE_ACTION_ADJUSTMENT", Swig_var_PosType_CORPORATE_ACTION_ADJUSTMENT_get, Swig_var_PosType_CORPORATE_ACTION_ADJUSTMENT_set);
  SWIG_addvarlink(globals, "PosType_DELIVERY_NOTICE_QTY", Swig_var_PosType_DELIVERY_NOTICE_QTY_get, Swig_var_PosType_DELIVERY_NOTICE_QTY_set);
  SWIG_addvarlink(globals, "PosType_EXCHANGE_FOR_PHYSICAL_QTY", Swig_var_PosType_EXCHANGE_FOR_PHYSICAL_QTY_get, Swig_var_PosType_EXCHANGE_FOR_PHYSICAL_QTY_set);
  SWIG_addvarlink(globals, "PosType_PRIVATELY_NEGOTIATED_TRADE_QTY", Swig_var_PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_get, Swig_var_PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_set);
  SWIG_addvarlink(globals, "PosType_NET_DELTA_QTY", Swig_var_PosType_NET_DELTA_QTY_get, Swig_var_PosType_NET_DELTA_QTY_set);
  SWIG_addvarlink(globals, "PosType_CREDIT_EVENT_ADJUSTMENT", Swig_var_PosType_CREDIT_EVENT_ADJUSTMENT_get, Swig_var_PosType_CREDIT_EVENT_ADJUSTMENT_set);
  SWIG_addvarlink(globals, "PosType_SUCCESSION_EVENT_ADJUSTMENT", Swig_var_PosType_SUCCESSION_EVENT_ADJUSTMENT_get, Swig_var_PosType_SUCCESSION_EVENT_ADJUSTMENT_set);
  SWIG_addvarlink(globals, "PosType_NET_QTY", Swig_var_PosType_NET_QTY_get, Swig_var_PosType_NET_QTY_set);
  SWIG_addvarlink(globals, "PosType_GROSS_QTY", Swig_var_PosType_GROSS_QTY_get, Swig_var_PosType_GROSS_QTY_set);
  SWIG_addvarlink(globals, "PosType_INTRADAY_QTY", Swig_var_PosType_INTRADAY_QTY_get, Swig_var_PosType_INTRADAY_QTY_set);
  SWIG_addvarlink(globals, "PosType_GROSS_LONG_NON_DELTA_ADJUSTED_SWAPTION_POSITION", Swig_var_PosType_GROSS_LONG_NON_DELTA_ADJUSTED_SWAPTION_POSITION_get, Swig_var_PosType_GROSS_LONG_NON_DELTA_ADJUSTED_SWAPTION_POSITION_set);
  SWIG_addvarlink(globals, "PosType_LONG_DELTA_ADJUSTED_PAIRED_SWAPTION_POSITION", Swig_var_PosType_LONG_DELTA_ADJUSTED_PAIRED_SWAPTION_POSITION_get, Swig_var_PosType_LONG_DELTA_ADJUSTED_PAIRED_SWAPTION_POSITION_set);
  SWIG_addvarlink(globals, "PosType_EXPIRING_QUANTITY", Swig_var_PosType_EXPIRING_QUANTITY_get, Swig_var_PosType_EXPIRING_QUANTITY_set);
  SWIG_addvarlink(globals, "PosType_QUANTITY_NOT_EXERCISED", Swig_var_PosType_QUANTITY_NOT_EXERCISED_get, Swig_var_PosType_QUANTITY_NOT_EXERCISED_set);
  SWIG_addvarlink(globals, "PosType_REQUESTED_EXERCISE_QUANTITY", Swig_var_PosType_REQUESTED_EXERCISE_QUANTITY_get, Swig_var_PosType_REQUESTED_EXERCISE_QUANTITY_set);
  SWIG_addvarlink(globals, "PosType_CASH_FUTURES_EQUIVALENT_QUANTITY", Swig_var_PosType_CASH_FUTURES_EQUIVALENT_QUANTITY_get, Swig_var_PosType_CASH_FUTURES_EQUIVALENT_QUANTITY_set);
  SWIG_addvarlink(globals, "PosType_LOAN_OR_BORROWED_QUANTITY", Swig_var_PosType_LOAN_OR_BORROWED_QUANTITY_get, Swig_var_PosType_LOAN_OR_BORROWED_QUANTITY_set);
  SWIG_addvarlink(globals, "PosQtyStatus_SUBMITTED", Swig_var_PosQtyStatus_SUBMITTED_get, Swig_var_PosQtyStatus_SUBMITTED_set);
  SWIG_addvarlink(globals, "PosQtyStatus_ACCEPTED", Swig_var_PosQtyStatus_ACCEPTED_get, Swig_var_PosQtyStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "PosQtyStatus_REJECTED", Swig_var_PosQtyStatus_REJECTED_get, Swig_var_PosQtyStatus_REJECTED_set);
  SWIG_addvarlink(globals, "PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT", Swig_var_PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT_get, Swig_var_PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT", Swig_var_PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT_get, Swig_var_PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtType_TRADE_VARIATION_AMOUNT", Swig_var_PosAmtType_TRADE_VARIATION_AMOUNT_get, Swig_var_PosAmtType_TRADE_VARIATION_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT", Swig_var_PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT_get, Swig_var_PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtType_PREMIUM_AMOUNT", Swig_var_PosAmtType_PREMIUM_AMOUNT_get, Swig_var_PosAmtType_PREMIUM_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtType_CASH_RESIDUAL_AMOUNT", Swig_var_PosAmtType_CASH_RESIDUAL_AMOUNT_get, Swig_var_PosAmtType_CASH_RESIDUAL_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtType_CASH_AMOUNT", Swig_var_PosAmtType_CASH_AMOUNT_get, Swig_var_PosAmtType_CASH_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtType_VALUE_ADJUSTED_AMOUNT", Swig_var_PosAmtType_VALUE_ADJUSTED_AMOUNT_get, Swig_var_PosAmtType_VALUE_ADJUSTED_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtType_SETTLEMENT_VALUE", Swig_var_PosAmtType_SETTLEMENT_VALUE_get, Swig_var_PosAmtType_SETTLEMENT_VALUE_set);
  SWIG_addvarlink(globals, "PosAmtType_INITIAL_TRADE_COUPON_AMOUNT", Swig_var_PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_get, Swig_var_PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtType_ACCRUED_COUPON_AMOUNT", Swig_var_PosAmtType_ACCRUED_COUPON_AMOUNT_get, Swig_var_PosAmtType_ACCRUED_COUPON_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtType_COUPON_AMOUNT", Swig_var_PosAmtType_COUPON_AMOUNT_get, Swig_var_PosAmtType_COUPON_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtType_INCREMENTAL_ACCRUED_COUPON", Swig_var_PosAmtType_INCREMENTAL_ACCRUED_COUPON_get, Swig_var_PosAmtType_INCREMENTAL_ACCRUED_COUPON_set);
  SWIG_addvarlink(globals, "PosAmtType_COLLATERALIZED_MARK_TO_MARKET", Swig_var_PosAmtType_COLLATERALIZED_MARK_TO_MARKET_get, Swig_var_PosAmtType_COLLATERALIZED_MARK_TO_MARKET_set);
  SWIG_addvarlink(globals, "PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET", Swig_var_PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET_get, Swig_var_PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET_set);
  SWIG_addvarlink(globals, "PosAmtType_COMPENSATION_AMOUNT", Swig_var_PosAmtType_COMPENSATION_AMOUNT_get, Swig_var_PosAmtType_COMPENSATION_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtType_TOTAL_BANKED_AMOUNT", Swig_var_PosAmtType_TOTAL_BANKED_AMOUNT_get, Swig_var_PosAmtType_TOTAL_BANKED_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtType_TOTAL_COLLATERALIZED_AMOUNT", Swig_var_PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_get, Swig_var_PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtType_LONG_PAIRED_SWAP_NOTIONAL_VALUE", Swig_var_PosAmtType_LONG_PAIRED_SWAP_NOTIONAL_VALUE_get, Swig_var_PosAmtType_LONG_PAIRED_SWAP_NOTIONAL_VALUE_set);
  SWIG_addvarlink(globals, "PosAmtType_SHORT_PAIRED_SWAP_NOTIONAL_VALUE", Swig_var_PosAmtType_SHORT_PAIRED_SWAP_NOTIONAL_VALUE_get, Swig_var_PosAmtType_SHORT_PAIRED_SWAP_NOTIONAL_VALUE_set);
  SWIG_addvarlink(globals, "PosAmtType_START_OF_DAY_ACCRUED_COUPON", Swig_var_PosAmtType_START_OF_DAY_ACCRUED_COUPON_get, Swig_var_PosAmtType_START_OF_DAY_ACCRUED_COUPON_set);
  SWIG_addvarlink(globals, "PosAmtType_NET_PRESENT_VALUE", Swig_var_PosAmtType_NET_PRESENT_VALUE_get, Swig_var_PosAmtType_NET_PRESENT_VALUE_set);
  SWIG_addvarlink(globals, "PosAmtType_START_OF_DAY_NET_PRESENT_VALUE", Swig_var_PosAmtType_START_OF_DAY_NET_PRESENT_VALUE_get, Swig_var_PosAmtType_START_OF_DAY_NET_PRESENT_VALUE_set);
  SWIG_addvarlink(globals, "PosAmtType_NET_CASH_FLOW", Swig_var_PosAmtType_NET_CASH_FLOW_get, Swig_var_PosAmtType_NET_CASH_FLOW_set);
  SWIG_addvarlink(globals, "PosAmtType_PRESENT_VALUE_OF_FEES", Swig_var_PosAmtType_PRESENT_VALUE_OF_FEES_get, Swig_var_PosAmtType_PRESENT_VALUE_OF_FEES_set);
  SWIG_addvarlink(globals, "PosAmtType_PRESENT_VALUE_ONE_BASIS_POINTS", Swig_var_PosAmtType_PRESENT_VALUE_ONE_BASIS_POINTS_get, Swig_var_PosAmtType_PRESENT_VALUE_ONE_BASIS_POINTS_set);
  SWIG_addvarlink(globals, "PosAmtType_FIVE_YEAR_EQUIVALENT_NOTIONAL", Swig_var_PosAmtType_FIVE_YEAR_EQUIVALENT_NOTIONAL_get, Swig_var_PosAmtType_FIVE_YEAR_EQUIVALENT_NOTIONAL_set);
  SWIG_addvarlink(globals, "PosAmtType_UNDISCOUNTED_MARK_TO_MARKET", Swig_var_PosAmtType_UNDISCOUNTED_MARK_TO_MARKET_get, Swig_var_PosAmtType_UNDISCOUNTED_MARK_TO_MARKET_set);
  SWIG_addvarlink(globals, "PosAmtType_MARK_TO_MODEL", Swig_var_PosAmtType_MARK_TO_MODEL_get, Swig_var_PosAmtType_MARK_TO_MODEL_set);
  SWIG_addvarlink(globals, "PosAmtType_MARK_TO_MARKET_VARIANCE", Swig_var_PosAmtType_MARK_TO_MARKET_VARIANCE_get, Swig_var_PosAmtType_MARK_TO_MARKET_VARIANCE_set);
  SWIG_addvarlink(globals, "PosAmtType_MARK_TO_MODEL_VARIANCE", Swig_var_PosAmtType_MARK_TO_MODEL_VARIANCE_get, Swig_var_PosAmtType_MARK_TO_MODEL_VARIANCE_set);
  SWIG_addvarlink(globals, "PosAmtType_UPFRONT_PAYMENT", Swig_var_PosAmtType_UPFRONT_PAYMENT_get, Swig_var_PosAmtType_UPFRONT_PAYMENT_set);
  SWIG_addvarlink(globals, "PosAmtType_END_VALE", Swig_var_PosAmtType_END_VALE_get, Swig_var_PosAmtType_END_VALE_set);
  SWIG_addvarlink(globals, "PosAmtType_OUTSTANDING_MARGIN_LOAN", Swig_var_PosAmtType_OUTSTANDING_MARGIN_LOAN_get, Swig_var_PosAmtType_OUTSTANDING_MARGIN_LOAN_set);
  SWIG_addvarlink(globals, "PosAmtType_LOAN_VALUE", Swig_var_PosAmtType_LOAN_VALUE_get, Swig_var_PosAmtType_LOAN_VALUE_set);
  SWIG_addvarlink(globals, "PosTransType_EXERCISE", Swig_var_PosTransType_EXERCISE_get, Swig_var_PosTransType_EXERCISE_set);
  SWIG_addvarlink(globals, "PosTransType_DO_NOT_EXERCISE", Swig_var_PosTransType_DO_NOT_EXERCISE_get, Swig_var_PosTransType_DO_NOT_EXERCISE_set);
  SWIG_addvarlink(globals, "PosTransType_POSITION_ADJUSTMENT", Swig_var_PosTransType_POSITION_ADJUSTMENT_get, Swig_var_PosTransType_POSITION_ADJUSTMENT_set);
  SWIG_addvarlink(globals, "PosTransType_POSITION_CHANGE_SUBMISSION", Swig_var_PosTransType_POSITION_CHANGE_SUBMISSION_get, Swig_var_PosTransType_POSITION_CHANGE_SUBMISSION_set);
  SWIG_addvarlink(globals, "PosTransType_PLEDGE", Swig_var_PosTransType_PLEDGE_get, Swig_var_PosTransType_PLEDGE_set);
  SWIG_addvarlink(globals, "PosTransType_LARGE_TRADER_SUBMISSION", Swig_var_PosTransType_LARGE_TRADER_SUBMISSION_get, Swig_var_PosTransType_LARGE_TRADER_SUBMISSION_set);
  SWIG_addvarlink(globals, "PosTransType_LARGE_POSITIONS_REPORTING_SUBMISSION", Swig_var_PosTransType_LARGE_POSITIONS_REPORTING_SUBMISSION_get, Swig_var_PosTransType_LARGE_POSITIONS_REPORTING_SUBMISSION_set);
  SWIG_addvarlink(globals, "PosTransType_LONG_HOLDINGS", Swig_var_PosTransType_LONG_HOLDINGS_get, Swig_var_PosTransType_LONG_HOLDINGS_set);
  SWIG_addvarlink(globals, "PosTransType_INTERNAL_TRANSFER", Swig_var_PosTransType_INTERNAL_TRANSFER_get, Swig_var_PosTransType_INTERNAL_TRANSFER_set);
  SWIG_addvarlink(globals, "PosTransType_TRANSFER_OF_FIRM", Swig_var_PosTransType_TRANSFER_OF_FIRM_get, Swig_var_PosTransType_TRANSFER_OF_FIRM_set);
  SWIG_addvarlink(globals, "PosTransType_EXTERNAL_TRANSFER", Swig_var_PosTransType_EXTERNAL_TRANSFER_get, Swig_var_PosTransType_EXTERNAL_TRANSFER_set);
  SWIG_addvarlink(globals, "PosTransType_CORPORATE_ACTION", Swig_var_PosTransType_CORPORATE_ACTION_get, Swig_var_PosTransType_CORPORATE_ACTION_set);
  SWIG_addvarlink(globals, "PosTransType_NOTIFICATION", Swig_var_PosTransType_NOTIFICATION_get, Swig_var_PosTransType_NOTIFICATION_set);
  SWIG_addvarlink(globals, "PosTransType_POSITION_CREATION", Swig_var_PosTransType_POSITION_CREATION_get, Swig_var_PosTransType_POSITION_CREATION_set);
  SWIG_addvarlink(globals, "PosTransType_CLOSEOUT", Swig_var_PosTransType_CLOSEOUT_get, Swig_var_PosTransType_CLOSEOUT_set);
  SWIG_addvarlink(globals, "PosTransType_REOPEN", Swig_var_PosTransType_REOPEN_get, Swig_var_PosTransType_REOPEN_set);
  SWIG_addvarlink(globals, "PosMaintAction_NEW", Swig_var_PosMaintAction_NEW_get, Swig_var_PosMaintAction_NEW_set);
  SWIG_addvarlink(globals, "PosMaintAction_REPLACE", Swig_var_PosMaintAction_REPLACE_get, Swig_var_PosMaintAction_REPLACE_set);
  SWIG_addvarlink(globals, "PosMaintAction_CANCEL", Swig_var_PosMaintAction_CANCEL_get, Swig_var_PosMaintAction_CANCEL_set);
  SWIG_addvarlink(globals, "PosMaintAction_REVERSE", Swig_var_PosMaintAction_REVERSE_get, Swig_var_PosMaintAction_REVERSE_set);
  SWIG_addvarlink(globals, "SettlSessID_INTRADAY", Swig_var_SettlSessID_INTRADAY_get, Swig_var_SettlSessID_INTRADAY_set);
  SWIG_addvarlink(globals, "SettlSessID_REGULAR_TRADING_HOURS", Swig_var_SettlSessID_REGULAR_TRADING_HOURS_get, Swig_var_SettlSessID_REGULAR_TRADING_HOURS_set);
  SWIG_addvarlink(globals, "SettlSessID_ELECTRONIC_TRADING_HOURS", Swig_var_SettlSessID_ELECTRONIC_TRADING_HOURS_get, Swig_var_SettlSessID_ELECTRONIC_TRADING_HOURS_set);
  SWIG_addvarlink(globals, "SettlSessID_END_OF_DAY", Swig_var_SettlSessID_END_OF_DAY_get, Swig_var_SettlSessID_END_OF_DAY_set);
  SWIG_addvarlink(globals, "AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION", Swig_var_AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION_get, Swig_var_AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION_set);
  SWIG_addvarlink(globals, "AdjustmentType_DELTA_PLUS", Swig_var_AdjustmentType_DELTA_PLUS_get, Swig_var_AdjustmentType_DELTA_PLUS_set);
  SWIG_addvarlink(globals, "AdjustmentType_DELTA_MINUS", Swig_var_AdjustmentType_DELTA_MINUS_get, Swig_var_AdjustmentType_DELTA_MINUS_set);
  SWIG_addvarlink(globals, "AdjustmentType_FINAL", Swig_var_AdjustmentType_FINAL_get, Swig_var_AdjustmentType_FINAL_set);
  SWIG_addvarlink(globals, "AdjustmentType_CUSTOMER_SPECIFIC_POSITION", Swig_var_AdjustmentType_CUSTOMER_SPECIFIC_POSITION_get, Swig_var_AdjustmentType_CUSTOMER_SPECIFIC_POSITION_set);
  SWIG_addvarlink(globals, "PosMaintStatus_ACCEPTED", Swig_var_PosMaintStatus_ACCEPTED_get, Swig_var_PosMaintStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "PosMaintStatus_ACCEPTED_WITH_WARNINGS", Swig_var_PosMaintStatus_ACCEPTED_WITH_WARNINGS_get, Swig_var_PosMaintStatus_ACCEPTED_WITH_WARNINGS_set);
  SWIG_addvarlink(globals, "PosMaintStatus_REJECTED", Swig_var_PosMaintStatus_REJECTED_get, Swig_var_PosMaintStatus_REJECTED_set);
  SWIG_addvarlink(globals, "PosMaintStatus_COMPLETED", Swig_var_PosMaintStatus_COMPLETED_get, Swig_var_PosMaintStatus_COMPLETED_set);
  SWIG_addvarlink(globals, "PosMaintStatus_COMPLETED_WITH_WARNINGS", Swig_var_PosMaintStatus_COMPLETED_WITH_WARNINGS_get, Swig_var_PosMaintStatus_COMPLETED_WITH_WARNINGS_set);
  SWIG_addvarlink(globals, "PosMaintResult_SUCCESSFUL_COMPLETION", Swig_var_PosMaintResult_SUCCESSFUL_COMPLETION_get, Swig_var_PosMaintResult_SUCCESSFUL_COMPLETION_set);
  SWIG_addvarlink(globals, "PosMaintResult_REJECTED", Swig_var_PosMaintResult_REJECTED_get, Swig_var_PosMaintResult_REJECTED_set);
  SWIG_addvarlink(globals, "PosMaintResult_OTHER", Swig_var_PosMaintResult_OTHER_get, Swig_var_PosMaintResult_OTHER_set);
  SWIG_addvarlink(globals, "PosReqType_POSITIONS", Swig_var_PosReqType_POSITIONS_get, Swig_var_PosReqType_POSITIONS_set);
  SWIG_addvarlink(globals, "PosReqType_TRADES", Swig_var_PosReqType_TRADES_get, Swig_var_PosReqType_TRADES_set);
  SWIG_addvarlink(globals, "PosReqType_EXERCISES", Swig_var_PosReqType_EXERCISES_get, Swig_var_PosReqType_EXERCISES_set);
  SWIG_addvarlink(globals, "PosReqType_ASSIGNMENTS", Swig_var_PosReqType_ASSIGNMENTS_get, Swig_var_PosReqType_ASSIGNMENTS_set);
  SWIG_addvarlink(globals, "PosReqType_SETTLEMENT_ACTIVITY", Swig_var_PosReqType_SETTLEMENT_ACTIVITY_get, Swig_var_PosReqType_SETTLEMENT_ACTIVITY_set);
  SWIG_addvarlink(globals, "PosReqType_BACKOUT_MESSAGE", Swig_var_PosReqType_BACKOUT_MESSAGE_get, Swig_var_PosReqType_BACKOUT_MESSAGE_set);
  SWIG_addvarlink(globals, "PosReqType_DELTA_POSITIONS", Swig_var_PosReqType_DELTA_POSITIONS_get, Swig_var_PosReqType_DELTA_POSITIONS_set);
  SWIG_addvarlink(globals, "PosReqType_NET_POSITION", Swig_var_PosReqType_NET_POSITION_get, Swig_var_PosReqType_NET_POSITION_set);
  SWIG_addvarlink(globals, "PosReqType_LARGE_POSITIONS_REPORTING", Swig_var_PosReqType_LARGE_POSITIONS_REPORTING_get, Swig_var_PosReqType_LARGE_POSITIONS_REPORTING_set);
  SWIG_addvarlink(globals, "PosReqType_EXERCISE_POSITION_REPORTING_SUBMISSION", Swig_var_PosReqType_EXERCISE_POSITION_REPORTING_SUBMISSION_get, Swig_var_PosReqType_EXERCISE_POSITION_REPORTING_SUBMISSION_set);
  SWIG_addvarlink(globals, "PosReqType_POSITION_LIMIT_REPORTING_SUBMISSING", Swig_var_PosReqType_POSITION_LIMIT_REPORTING_SUBMISSING_get, Swig_var_PosReqType_POSITION_LIMIT_REPORTING_SUBMISSING_set);
  SWIG_addvarlink(globals, "ResponseTransportType_INBAND", Swig_var_ResponseTransportType_INBAND_get, Swig_var_ResponseTransportType_INBAND_set);
  SWIG_addvarlink(globals, "ResponseTransportType_OUT_OF_BAND", Swig_var_ResponseTransportType_OUT_OF_BAND_get, Swig_var_ResponseTransportType_OUT_OF_BAND_set);
  SWIG_addvarlink(globals, "PosReqResult_VALID_REQUEST", Swig_var_PosReqResult_VALID_REQUEST_get, Swig_var_PosReqResult_VALID_REQUEST_set);
  SWIG_addvarlink(globals, "PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST", Swig_var_PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST_get, Swig_var_PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST_set);
  SWIG_addvarlink(globals, "PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA", Swig_var_PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA_get, Swig_var_PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA_set);
  SWIG_addvarlink(globals, "PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS", Swig_var_PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS_get, Swig_var_PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS_set);
  SWIG_addvarlink(globals, "PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED", Swig_var_PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED_get, Swig_var_PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "PosReqResult_OTHER", Swig_var_PosReqResult_OTHER_get, Swig_var_PosReqResult_OTHER_set);
  SWIG_addvarlink(globals, "PosReqStatus_COMPLETED", Swig_var_PosReqStatus_COMPLETED_get, Swig_var_PosReqStatus_COMPLETED_set);
  SWIG_addvarlink(globals, "PosReqStatus_COMPLETED_WITH_WARNINGS", Swig_var_PosReqStatus_COMPLETED_WITH_WARNINGS_get, Swig_var_PosReqStatus_COMPLETED_WITH_WARNINGS_set);
  SWIG_addvarlink(globals, "PosReqStatus_REJECTED", Swig_var_PosReqStatus_REJECTED_get, Swig_var_PosReqStatus_REJECTED_set);
  SWIG_addvarlink(globals, "SettlPriceType_FINAL", Swig_var_SettlPriceType_FINAL_get, Swig_var_SettlPriceType_FINAL_set);
  SWIG_addvarlink(globals, "SettlPriceType_THEORETICAL", Swig_var_SettlPriceType_THEORETICAL_get, Swig_var_SettlPriceType_THEORETICAL_set);
  SWIG_addvarlink(globals, "AssignmentMethod_RANDOM", Swig_var_AssignmentMethod_RANDOM_get, Swig_var_AssignmentMethod_RANDOM_set);
  SWIG_addvarlink(globals, "AssignmentMethod_PRO_RATA", Swig_var_AssignmentMethod_PRO_RATA_get, Swig_var_AssignmentMethod_PRO_RATA_set);
  SWIG_addvarlink(globals, "ExerciseMethod_AUTOMATIC", Swig_var_ExerciseMethod_AUTOMATIC_get, Swig_var_ExerciseMethod_AUTOMATIC_set);
  SWIG_addvarlink(globals, "ExerciseMethod_MANUAL", Swig_var_ExerciseMethod_MANUAL_get, Swig_var_ExerciseMethod_MANUAL_set);
  SWIG_addvarlink(globals, "TradeRequestResult_SUCCESSFUL", Swig_var_TradeRequestResult_SUCCESSFUL_get, Swig_var_TradeRequestResult_SUCCESSFUL_set);
  SWIG_addvarlink(globals, "TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT", Swig_var_TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT_get, Swig_var_TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT_set);
  SWIG_addvarlink(globals, "TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED", Swig_var_TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED_get, Swig_var_TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED_set);
  SWIG_addvarlink(globals, "TradeRequestResult_INVALID_PARTIES", Swig_var_TradeRequestResult_INVALID_PARTIES_get, Swig_var_TradeRequestResult_INVALID_PARTIES_set);
  SWIG_addvarlink(globals, "TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED", Swig_var_TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED_get, Swig_var_TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED_set);
  SWIG_addvarlink(globals, "TradeRequestResult_INVALID_DESTINATION_REQUESTED", Swig_var_TradeRequestResult_INVALID_DESTINATION_REQUESTED_get, Swig_var_TradeRequestResult_INVALID_DESTINATION_REQUESTED_set);
  SWIG_addvarlink(globals, "TradeRequestResult_TRADE_REQUEST_TYPE_NOT_SUPPORTED", Swig_var_TradeRequestResult_TRADE_REQUEST_TYPE_NOT_SUPPORTED_get, Swig_var_TradeRequestResult_TRADE_REQUEST_TYPE_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "TradeRequestResult_NOT_AUTHORIZED", Swig_var_TradeRequestResult_NOT_AUTHORIZED_get, Swig_var_TradeRequestResult_NOT_AUTHORIZED_set);
  SWIG_addvarlink(globals, "TradeRequestResult_OTHER", Swig_var_TradeRequestResult_OTHER_get, Swig_var_TradeRequestResult_OTHER_set);
  SWIG_addvarlink(globals, "TradeRequestStatus_ACCEPTED", Swig_var_TradeRequestStatus_ACCEPTED_get, Swig_var_TradeRequestStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "TradeRequestStatus_COMPLETED", Swig_var_TradeRequestStatus_COMPLETED_get, Swig_var_TradeRequestStatus_COMPLETED_set);
  SWIG_addvarlink(globals, "TradeRequestStatus_REJECTED", Swig_var_TradeRequestStatus_REJECTED_get, Swig_var_TradeRequestStatus_REJECTED_set);
  SWIG_addvarlink(globals, "TradeReportRejectReason_SUCCESSFUL", Swig_var_TradeReportRejectReason_SUCCESSFUL_get, Swig_var_TradeReportRejectReason_SUCCESSFUL_set);
  SWIG_addvarlink(globals, "TradeReportRejectReason_INVALID_PARTY_ONFORMATION", Swig_var_TradeReportRejectReason_INVALID_PARTY_ONFORMATION_get, Swig_var_TradeReportRejectReason_INVALID_PARTY_ONFORMATION_set);
  SWIG_addvarlink(globals, "TradeReportRejectReason_UNKNOWN_INSTRUMENT", Swig_var_TradeReportRejectReason_UNKNOWN_INSTRUMENT_get, Swig_var_TradeReportRejectReason_UNKNOWN_INSTRUMENT_set);
  SWIG_addvarlink(globals, "TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES", Swig_var_TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES_get, Swig_var_TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES_set);
  SWIG_addvarlink(globals, "TradeReportRejectReason_INVALID_TRADE_TYPE", Swig_var_TradeReportRejectReason_INVALID_TRADE_TYPE_get, Swig_var_TradeReportRejectReason_INVALID_TRADE_TYPE_set);
  SWIG_addvarlink(globals, "TradeReportRejectReason_OTHER", Swig_var_TradeReportRejectReason_OTHER_get, Swig_var_TradeReportRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "TradeReportRejectReason_INVALID_PARTY_INFORMATION", Swig_var_TradeReportRejectReason_INVALID_PARTY_INFORMATION_get, Swig_var_TradeReportRejectReason_INVALID_PARTY_INFORMATION_set);
  SWIG_addvarlink(globals, "TradeReportRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND", Swig_var_TradeReportRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get, Swig_var_TradeReportRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set);
  SWIG_addvarlink(globals, "TradeReportRejectReason_REFERENCE_PRICE_NOT_AVAILABLE", Swig_var_TradeReportRejectReason_REFERENCE_PRICE_NOT_AVAILABLE_get, Swig_var_TradeReportRejectReason_REFERENCE_PRICE_NOT_AVAILABLE_set);
  SWIG_addvarlink(globals, "TradeReportRejectReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD", Swig_var_TradeReportRejectReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD_get, Swig_var_TradeReportRejectReason_NOTIONAL_VALUE_EXCEEDS_THRESHOLD_set);
  SWIG_addvarlink(globals, "SideMultiLegReportingType_SINGLE_SECURITY", Swig_var_SideMultiLegReportingType_SINGLE_SECURITY_get, Swig_var_SideMultiLegReportingType_SINGLE_SECURITY_set);
  SWIG_addvarlink(globals, "SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY", Swig_var_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_get, Swig_var_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_set);
  SWIG_addvarlink(globals, "SideMultiLegReportingType_MULTILEG_SECURITY", Swig_var_SideMultiLegReportingType_MULTILEG_SECURITY_get, Swig_var_SideMultiLegReportingType_MULTILEG_SECURITY_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_EXECUTION_TIME", Swig_var_TrdRegTimestampType_EXECUTION_TIME_get, Swig_var_TrdRegTimestampType_EXECUTION_TIME_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_TIME_IN", Swig_var_TrdRegTimestampType_TIME_IN_get, Swig_var_TrdRegTimestampType_TIME_IN_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_TIME_OUT", Swig_var_TrdRegTimestampType_TIME_OUT_get, Swig_var_TrdRegTimestampType_TIME_OUT_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_BROKER_RECEIPT", Swig_var_TrdRegTimestampType_BROKER_RECEIPT_get, Swig_var_TrdRegTimestampType_BROKER_RECEIPT_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_BROKER_EXECUTION", Swig_var_TrdRegTimestampType_BROKER_EXECUTION_get, Swig_var_TrdRegTimestampType_BROKER_EXECUTION_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_DESK_RECEIPT", Swig_var_TrdRegTimestampType_DESK_RECEIPT_get, Swig_var_TrdRegTimestampType_DESK_RECEIPT_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_SUBMISSION_TO_CLEARING", Swig_var_TrdRegTimestampType_SUBMISSION_TO_CLEARING_get, Swig_var_TrdRegTimestampType_SUBMISSION_TO_CLEARING_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_TIME_PRIORITY", Swig_var_TrdRegTimestampType_TIME_PRIORITY_get, Swig_var_TrdRegTimestampType_TIME_PRIORITY_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_ORDERBOOK_ENTRY_TIME", Swig_var_TrdRegTimestampType_ORDERBOOK_ENTRY_TIME_get, Swig_var_TrdRegTimestampType_ORDERBOOK_ENTRY_TIME_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_ORDER_SUBMISSION_TIME", Swig_var_TrdRegTimestampType_ORDER_SUBMISSION_TIME_get, Swig_var_TrdRegTimestampType_ORDER_SUBMISSION_TIME_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_PUBLICLY_REPORTED", Swig_var_TrdRegTimestampType_PUBLICLY_REPORTED_get, Swig_var_TrdRegTimestampType_PUBLICLY_REPORTED_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_PUBLIC_REPORT_UPDATED", Swig_var_TrdRegTimestampType_PUBLIC_REPORT_UPDATED_get, Swig_var_TrdRegTimestampType_PUBLIC_REPORT_UPDATED_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_NON_PUBLICLY_REPORTED", Swig_var_TrdRegTimestampType_NON_PUBLICLY_REPORTED_get, Swig_var_TrdRegTimestampType_NON_PUBLICLY_REPORTED_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_NON_PUBLIC_REPORT_UPDATED", Swig_var_TrdRegTimestampType_NON_PUBLIC_REPORT_UPDATED_get, Swig_var_TrdRegTimestampType_NON_PUBLIC_REPORT_UPDATED_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_SUBMITTED_FOR_CONFIRMATION", Swig_var_TrdRegTimestampType_SUBMITTED_FOR_CONFIRMATION_get, Swig_var_TrdRegTimestampType_SUBMITTED_FOR_CONFIRMATION_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_UPDATED_FOR_CONFIRMATION", Swig_var_TrdRegTimestampType_UPDATED_FOR_CONFIRMATION_get, Swig_var_TrdRegTimestampType_UPDATED_FOR_CONFIRMATION_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_CONFIRMED", Swig_var_TrdRegTimestampType_CONFIRMED_get, Swig_var_TrdRegTimestampType_CONFIRMED_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_UPDATED_FOR_CLEARING", Swig_var_TrdRegTimestampType_UPDATED_FOR_CLEARING_get, Swig_var_TrdRegTimestampType_UPDATED_FOR_CLEARING_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_CLEARED", Swig_var_TrdRegTimestampType_CLEARED_get, Swig_var_TrdRegTimestampType_CLEARED_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_ALLOCATIONS_SUBMITTED", Swig_var_TrdRegTimestampType_ALLOCATIONS_SUBMITTED_get, Swig_var_TrdRegTimestampType_ALLOCATIONS_SUBMITTED_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_ALLOCATIONS_UPDATED", Swig_var_TrdRegTimestampType_ALLOCATIONS_UPDATED_get, Swig_var_TrdRegTimestampType_ALLOCATIONS_UPDATED_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_ALLOCATIONS_COMPLETED", Swig_var_TrdRegTimestampType_ALLOCATIONS_COMPLETED_get, Swig_var_TrdRegTimestampType_ALLOCATIONS_COMPLETED_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_SUBMITTED_TO_REPOSITORY", Swig_var_TrdRegTimestampType_SUBMITTED_TO_REPOSITORY_get, Swig_var_TrdRegTimestampType_SUBMITTED_TO_REPOSITORY_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_POST_TRD_CONTNTN_EVNT", Swig_var_TrdRegTimestampType_POST_TRD_CONTNTN_EVNT_get, Swig_var_TrdRegTimestampType_POST_TRD_CONTNTN_EVNT_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_POST_TRADE_VALUATION", Swig_var_TrdRegTimestampType_POST_TRADE_VALUATION_get, Swig_var_TrdRegTimestampType_POST_TRADE_VALUATION_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_PREVIOUS_TIME_PRIORITY", Swig_var_TrdRegTimestampType_PREVIOUS_TIME_PRIORITY_get, Swig_var_TrdRegTimestampType_PREVIOUS_TIME_PRIORITY_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_IDENTIFIER_ASSIGNED", Swig_var_TrdRegTimestampType_IDENTIFIER_ASSIGNED_get, Swig_var_TrdRegTimestampType_IDENTIFIER_ASSIGNED_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_PREVIOUS_IDENTIFIER_ASSIGNED", Swig_var_TrdRegTimestampType_PREVIOUS_IDENTIFIER_ASSIGNED_get, Swig_var_TrdRegTimestampType_PREVIOUS_IDENTIFIER_ASSIGNED_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_ORDER_CANCELLATION_TIME", Swig_var_TrdRegTimestampType_ORDER_CANCELLATION_TIME_get, Swig_var_TrdRegTimestampType_ORDER_CANCELLATION_TIME_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_ORDER_MODIFICATION_TIME", Swig_var_TrdRegTimestampType_ORDER_MODIFICATION_TIME_get, Swig_var_TrdRegTimestampType_ORDER_MODIFICATION_TIME_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_ORDER_ROUTING_TIME", Swig_var_TrdRegTimestampType_ORDER_ROUTING_TIME_get, Swig_var_TrdRegTimestampType_ORDER_ROUTING_TIME_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_TRADE_CANCELLATION_TIME", Swig_var_TrdRegTimestampType_TRADE_CANCELLATION_TIME_get, Swig_var_TrdRegTimestampType_TRADE_CANCELLATION_TIME_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_TRADE_MODIFICATION_TIME", Swig_var_TrdRegTimestampType_TRADE_MODIFICATION_TIME_get, Swig_var_TrdRegTimestampType_TRADE_MODIFICATION_TIME_set);
  SWIG_addvarlink(globals, "TrdRegTimestampType_REFERENCE_TIME_FOR_NBBO", Swig_var_TrdRegTimestampType_REFERENCE_TIME_FOR_NBBO_get, Swig_var_TrdRegTimestampType_REFERENCE_TIME_FOR_NBBO_set);
  SWIG_addvarlink(globals, "ConfirmType_STATUS", Swig_var_ConfirmType_STATUS_get, Swig_var_ConfirmType_STATUS_set);
  SWIG_addvarlink(globals, "ConfirmType_CONFIRMATION", Swig_var_ConfirmType_CONFIRMATION_get, Swig_var_ConfirmType_CONFIRMATION_set);
  SWIG_addvarlink(globals, "ConfirmType_CONFIRMATION_REQUEST_REJECTED", Swig_var_ConfirmType_CONFIRMATION_REQUEST_REJECTED_get, Swig_var_ConfirmType_CONFIRMATION_REQUEST_REJECTED_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_MISMATCHED_ACCOUNT", Swig_var_ConfirmRejReason_MISMATCHED_ACCOUNT_get, Swig_var_ConfirmRejReason_MISMATCHED_ACCOUNT_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS", Swig_var_ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS_get, Swig_var_ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_OTHER", Swig_var_ConfirmRejReason_OTHER_get, Swig_var_ConfirmRejReason_OTHER_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_UNKNOWN_OR_MISSING_INDIVIDUAL_ALLOC_ID", Swig_var_ConfirmRejReason_UNKNOWN_OR_MISSING_INDIVIDUAL_ALLOC_ID_get, Swig_var_ConfirmRejReason_UNKNOWN_OR_MISSING_INDIVIDUAL_ALLOC_ID_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_TRANSACTION_NOT_RECOGNIZED", Swig_var_ConfirmRejReason_TRANSACTION_NOT_RECOGNIZED_get, Swig_var_ConfirmRejReason_TRANSACTION_NOT_RECOGNIZED_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_DUPLICATE_TRANSACTION", Swig_var_ConfirmRejReason_DUPLICATE_TRANSACTION_get, Swig_var_ConfirmRejReason_DUPLICATE_TRANSACTION_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_INCORRECT_OR_MISSING_INSTRUMENT", Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_INSTRUMENT_get, Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_INSTRUMENT_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_INCORRECT_OR_MISSING_PRICE", Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_PRICE_get, Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_PRICE_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_INCORRECT_OR_MISSING_COMMISSION", Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_COMMISSION_get, Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_COMMISSION_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_INCORRECT_OR_MISSING_SETTL_DATE", Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_SETTL_DATE_get, Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_SETTL_DATE_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_INCORRECT_OR_MISSING_FUND_ID_OR_FUND_NAME", Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_FUND_ID_OR_FUND_NAME_get, Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_FUND_ID_OR_FUND_NAME_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_INCORRECT_OR_MISSING_QUANTITY", Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_QUANTITY_get, Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_QUANTITY_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_INCORRECT_OR_MISSING_FEES", Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_FEES_get, Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_FEES_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_INCORRECT_OR_MISSING_TAX", Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_TAX_get, Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_TAX_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_INCORRECT_OR_MISSING_PARTY", Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_PARTY_get, Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_PARTY_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_INCORRECT_OR_MISSING_SIDE", Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_SIDE_get, Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_SIDE_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_INCORRECT_OR_MISSING_NET_MONEY", Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_NET_MONEY_get, Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_NET_MONEY_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_INCORRECT_OR_MISSING_TRADE_DATE", Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_TRADE_DATE_get, Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_TRADE_DATE_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_INCORRECT_OR_MISSING_SETTL_CCY_INSTRUCTIONS", Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_SETTL_CCY_INSTRUCTIONS_get, Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_SETTL_CCY_INSTRUCTIONS_set);
  SWIG_addvarlink(globals, "ConfirmRejReason_INCORRECT_OR_MISSING_CAPACITY", Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_CAPACITY_get, Swig_var_ConfirmRejReason_INCORRECT_OR_MISSING_CAPACITY_set);
  SWIG_addvarlink(globals, "BookingType_REGULAR_BOOKING", Swig_var_BookingType_REGULAR_BOOKING_get, Swig_var_BookingType_REGULAR_BOOKING_set);
  SWIG_addvarlink(globals, "BookingType_CFD", Swig_var_BookingType_CFD_get, Swig_var_BookingType_CFD_set);
  SWIG_addvarlink(globals, "BookingType_TOTAL_RETURN_SWAP", Swig_var_BookingType_TOTAL_RETURN_SWAP_get, Swig_var_BookingType_TOTAL_RETURN_SWAP_set);
  SWIG_addvarlink(globals, "AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS", Swig_var_AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS_get, Swig_var_AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS_set);
  SWIG_addvarlink(globals, "AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED", Swig_var_AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED_get, Swig_var_AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED_set);
  SWIG_addvarlink(globals, "AllocSettlInstType_FULL_DETAILS_PROVIDED", Swig_var_AllocSettlInstType_FULL_DETAILS_PROVIDED_get, Swig_var_AllocSettlInstType_FULL_DETAILS_PROVIDED_set);
  SWIG_addvarlink(globals, "AllocSettlInstType_SSIDBI_DS_PROVIDED", Swig_var_AllocSettlInstType_SSIDBI_DS_PROVIDED_get, Swig_var_AllocSettlInstType_SSIDBI_DS_PROVIDED_set);
  SWIG_addvarlink(globals, "AllocSettlInstType_PHONE_FOR_INSTRUCTIONS", Swig_var_AllocSettlInstType_PHONE_FOR_INSTRUCTIONS_get, Swig_var_AllocSettlInstType_PHONE_FOR_INSTRUCTIONS_set);
  SWIG_addvarlink(globals, "DlvyInstType_SECURITIES", Swig_var_DlvyInstType_SECURITIES_get, Swig_var_DlvyInstType_SECURITIES_set);
  SWIG_addvarlink(globals, "DlvyInstType_CASH", Swig_var_DlvyInstType_CASH_get, Swig_var_DlvyInstType_CASH_set);
  SWIG_addvarlink(globals, "TerminationType_OVERNIGHT", Swig_var_TerminationType_OVERNIGHT_get, Swig_var_TerminationType_OVERNIGHT_set);
  SWIG_addvarlink(globals, "TerminationType_TERM", Swig_var_TerminationType_TERM_get, Swig_var_TerminationType_TERM_set);
  SWIG_addvarlink(globals, "TerminationType_FLEXIBLE", Swig_var_TerminationType_FLEXIBLE_get, Swig_var_TerminationType_FLEXIBLE_set);
  SWIG_addvarlink(globals, "TerminationType_OPEN", Swig_var_TerminationType_OPEN_get, Swig_var_TerminationType_OPEN_set);
  SWIG_addvarlink(globals, "SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST", Swig_var_SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST_get, Swig_var_SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST_set);
  SWIG_addvarlink(globals, "SettlInstReqRejCode_UNKNOWN_ACCOUNT", Swig_var_SettlInstReqRejCode_UNKNOWN_ACCOUNT_get, Swig_var_SettlInstReqRejCode_UNKNOWN_ACCOUNT_set);
  SWIG_addvarlink(globals, "SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND", Swig_var_SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND_get, Swig_var_SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND_set);
  SWIG_addvarlink(globals, "SettlInstReqRejCode_OTHER", Swig_var_SettlInstReqRejCode_OTHER_get, Swig_var_SettlInstReqRejCode_OTHER_set);
  SWIG_addvarlink(globals, "AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY", Swig_var_AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get, Swig_var_AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY_set);
  SWIG_addvarlink(globals, "AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY", Swig_var_AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get, Swig_var_AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_set);
  SWIG_addvarlink(globals, "AllocReportType_WAREHOUSE_RECAP", Swig_var_AllocReportType_WAREHOUSE_RECAP_get, Swig_var_AllocReportType_WAREHOUSE_RECAP_set);
  SWIG_addvarlink(globals, "AllocReportType_REQUEST_TO_INTERMEDIARY", Swig_var_AllocReportType_REQUEST_TO_INTERMEDIARY_get, Swig_var_AllocReportType_REQUEST_TO_INTERMEDIARY_set);
  SWIG_addvarlink(globals, "AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY", Swig_var_AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY_get, Swig_var_AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY_set);
  SWIG_addvarlink(globals, "AllocReportType_ACCEPT", Swig_var_AllocReportType_ACCEPT_get, Swig_var_AllocReportType_ACCEPT_set);
  SWIG_addvarlink(globals, "AllocReportType_REJECT", Swig_var_AllocReportType_REJECT_get, Swig_var_AllocReportType_REJECT_set);
  SWIG_addvarlink(globals, "AllocReportType_ACCEPT_PENDING", Swig_var_AllocReportType_ACCEPT_PENDING_get, Swig_var_AllocReportType_ACCEPT_PENDING_set);
  SWIG_addvarlink(globals, "AllocReportType_COMPLETE", Swig_var_AllocReportType_COMPLETE_get, Swig_var_AllocReportType_COMPLETE_set);
  SWIG_addvarlink(globals, "AllocReportType_REVERSE_PENDING", Swig_var_AllocReportType_REVERSE_PENDING_get, Swig_var_AllocReportType_REVERSE_PENDING_set);
  SWIG_addvarlink(globals, "AllocReportType_GIVEUP", Swig_var_AllocReportType_GIVEUP_get, Swig_var_AllocReportType_GIVEUP_set);
  SWIG_addvarlink(globals, "AllocReportType_TAKEUP", Swig_var_AllocReportType_TAKEUP_get, Swig_var_AllocReportType_TAKEUP_set);
  SWIG_addvarlink(globals, "AllocReportType_REVERSAL", Swig_var_AllocReportType_REVERSAL_get, Swig_var_AllocReportType_REVERSAL_set);
  SWIG_addvarlink(globals, "AllocReportType_ALLEGED", Swig_var_AllocReportType_ALLEGED_get, Swig_var_AllocReportType_ALLEGED_set);
  SWIG_addvarlink(globals, "AllocReportType_SUB_ALLOCATION_GIVEUP", Swig_var_AllocReportType_SUB_ALLOCATION_GIVEUP_get, Swig_var_AllocReportType_SUB_ALLOCATION_GIVEUP_set);
  SWIG_addvarlink(globals, "AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE", Swig_var_AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_get, Swig_var_AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_set);
  SWIG_addvarlink(globals, "AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS", Swig_var_AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS_get, Swig_var_AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS_set);
  SWIG_addvarlink(globals, "AllocCancReplaceReason_OTHER", Swig_var_AllocCancReplaceReason_OTHER_get, Swig_var_AllocCancReplaceReason_OTHER_set);
  SWIG_addvarlink(globals, "AllocCancReplaceReason_CANCELLED_BY_GIVEUP_FIRM", Swig_var_AllocCancReplaceReason_CANCELLED_BY_GIVEUP_FIRM_get, Swig_var_AllocCancReplaceReason_CANCELLED_BY_GIVEUP_FIRM_set);
  SWIG_addvarlink(globals, "AllocAccountType_CARRIED_CUSTOMER_SIDE", Swig_var_AllocAccountType_CARRIED_CUSTOMER_SIDE_get, Swig_var_AllocAccountType_CARRIED_CUSTOMER_SIDE_set);
  SWIG_addvarlink(globals, "AllocAccountType_CARRIED_NON_CUSTOMER_SIDE", Swig_var_AllocAccountType_CARRIED_NON_CUSTOMER_SIDE_get, Swig_var_AllocAccountType_CARRIED_NON_CUSTOMER_SIDE_set);
  SWIG_addvarlink(globals, "AllocAccountType_HOUSE_TRADER", Swig_var_AllocAccountType_HOUSE_TRADER_get, Swig_var_AllocAccountType_HOUSE_TRADER_set);
  SWIG_addvarlink(globals, "AllocAccountType_FLOOR_TRADER", Swig_var_AllocAccountType_FLOOR_TRADER_get, Swig_var_AllocAccountType_FLOOR_TRADER_set);
  SWIG_addvarlink(globals, "AllocAccountType_CARRIED_NON_CUSTOMER_SIDE_CROSS_MARGINED", Swig_var_AllocAccountType_CARRIED_NON_CUSTOMER_SIDE_CROSS_MARGINED_get, Swig_var_AllocAccountType_CARRIED_NON_CUSTOMER_SIDE_CROSS_MARGINED_set);
  SWIG_addvarlink(globals, "AllocAccountType_HOUSE_TRADER_CROSS_MARGINED", Swig_var_AllocAccountType_HOUSE_TRADER_CROSS_MARGINED_get, Swig_var_AllocAccountType_HOUSE_TRADER_CROSS_MARGINED_set);
  SWIG_addvarlink(globals, "AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT", Swig_var_AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT_get, Swig_var_AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartySubIDType_FIRM", Swig_var_PartySubIDType_FIRM_get, Swig_var_PartySubIDType_FIRM_set);
  SWIG_addvarlink(globals, "PartySubIDType_PERSON", Swig_var_PartySubIDType_PERSON_get, Swig_var_PartySubIDType_PERSON_set);
  SWIG_addvarlink(globals, "PartySubIDType_SYSTEM", Swig_var_PartySubIDType_SYSTEM_get, Swig_var_PartySubIDType_SYSTEM_set);
  SWIG_addvarlink(globals, "PartySubIDType_APPLICATION", Swig_var_PartySubIDType_APPLICATION_get, Swig_var_PartySubIDType_APPLICATION_set);
  SWIG_addvarlink(globals, "PartySubIDType_FULL_LEGAL_NAME_OF_FIRM", Swig_var_PartySubIDType_FULL_LEGAL_NAME_OF_FIRM_get, Swig_var_PartySubIDType_FULL_LEGAL_NAME_OF_FIRM_set);
  SWIG_addvarlink(globals, "PartySubIDType_POSTAL_ADDRESS", Swig_var_PartySubIDType_POSTAL_ADDRESS_get, Swig_var_PartySubIDType_POSTAL_ADDRESS_set);
  SWIG_addvarlink(globals, "PartySubIDType_PHONE_NUMBER", Swig_var_PartySubIDType_PHONE_NUMBER_get, Swig_var_PartySubIDType_PHONE_NUMBER_set);
  SWIG_addvarlink(globals, "PartySubIDType_EMAIL_ADDRESS", Swig_var_PartySubIDType_EMAIL_ADDRESS_get, Swig_var_PartySubIDType_EMAIL_ADDRESS_set);
  SWIG_addvarlink(globals, "PartySubIDType_CONTACT_NAME", Swig_var_PartySubIDType_CONTACT_NAME_get, Swig_var_PartySubIDType_CONTACT_NAME_set);
  SWIG_addvarlink(globals, "PartySubIDType_SECURITIES_ACCOUNT_NUMBER", Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NUMBER_get, Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NUMBER_set);
  SWIG_addvarlink(globals, "PartySubIDType_REGISTRATION_NUMBER", Swig_var_PartySubIDType_REGISTRATION_NUMBER_get, Swig_var_PartySubIDType_REGISTRATION_NUMBER_set);
  SWIG_addvarlink(globals, "PartySubIDType_REGISTERED_ADDRESS_FOR_CONFIRMATION", Swig_var_PartySubIDType_REGISTERED_ADDRESS_FOR_CONFIRMATION_get, Swig_var_PartySubIDType_REGISTERED_ADDRESS_FOR_CONFIRMATION_set);
  SWIG_addvarlink(globals, "PartySubIDType_REGULATORY_STATUS", Swig_var_PartySubIDType_REGULATORY_STATUS_get, Swig_var_PartySubIDType_REGULATORY_STATUS_set);
  SWIG_addvarlink(globals, "PartySubIDType_REGISTRATION_NAME", Swig_var_PartySubIDType_REGISTRATION_NAME_get, Swig_var_PartySubIDType_REGISTRATION_NAME_set);
  SWIG_addvarlink(globals, "PartySubIDType_CASH_ACCOUNT_NUMBER", Swig_var_PartySubIDType_CASH_ACCOUNT_NUMBER_get, Swig_var_PartySubIDType_CASH_ACCOUNT_NUMBER_set);
  SWIG_addvarlink(globals, "PartySubIDType_BIC", Swig_var_PartySubIDType_BIC_get, Swig_var_PartySubIDType_BIC_set);
  SWIG_addvarlink(globals, "PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE", Swig_var_PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE_get, Swig_var_PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE_set);
  SWIG_addvarlink(globals, "PartySubIDType_REGISTERED_ADDRESS", Swig_var_PartySubIDType_REGISTERED_ADDRESS_get, Swig_var_PartySubIDType_REGISTERED_ADDRESS_set);
  SWIG_addvarlink(globals, "PartySubIDType_FUND_ACCOUNT_NAME", Swig_var_PartySubIDType_FUND_ACCOUNT_NAME_get, Swig_var_PartySubIDType_FUND_ACCOUNT_NAME_set);
  SWIG_addvarlink(globals, "PartySubIDType_TELEX_NUMBER", Swig_var_PartySubIDType_TELEX_NUMBER_get, Swig_var_PartySubIDType_TELEX_NUMBER_set);
  SWIG_addvarlink(globals, "PartySubIDType_FAX_NUMBER", Swig_var_PartySubIDType_FAX_NUMBER_get, Swig_var_PartySubIDType_FAX_NUMBER_set);
  SWIG_addvarlink(globals, "PartySubIDType_SECURITIES_ACCOUNT_NAME", Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NAME_get, Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NAME_set);
  SWIG_addvarlink(globals, "PartySubIDType_CASH_ACCOUNT_NAME", Swig_var_PartySubIDType_CASH_ACCOUNT_NAME_get, Swig_var_PartySubIDType_CASH_ACCOUNT_NAME_set);
  SWIG_addvarlink(globals, "PartySubIDType_DEPARTMENT", Swig_var_PartySubIDType_DEPARTMENT_get, Swig_var_PartySubIDType_DEPARTMENT_set);
  SWIG_addvarlink(globals, "PartySubIDType_LOCATION_DESK", Swig_var_PartySubIDType_LOCATION_DESK_get, Swig_var_PartySubIDType_LOCATION_DESK_set);
  SWIG_addvarlink(globals, "PartySubIDType_POSITION_ACCOUNT_TYPE", Swig_var_PartySubIDType_POSITION_ACCOUNT_TYPE_get, Swig_var_PartySubIDType_POSITION_ACCOUNT_TYPE_set);
  SWIG_addvarlink(globals, "PartySubIDType_SECURITY_LOCATE_ID", Swig_var_PartySubIDType_SECURITY_LOCATE_ID_get, Swig_var_PartySubIDType_SECURITY_LOCATE_ID_set);
  SWIG_addvarlink(globals, "PartySubIDType_MARKET_MAKER", Swig_var_PartySubIDType_MARKET_MAKER_get, Swig_var_PartySubIDType_MARKET_MAKER_set);
  SWIG_addvarlink(globals, "PartySubIDType_ELIGIBLE_COUNTERPARTY", Swig_var_PartySubIDType_ELIGIBLE_COUNTERPARTY_get, Swig_var_PartySubIDType_ELIGIBLE_COUNTERPARTY_set);
  SWIG_addvarlink(globals, "PartySubIDType_PROFESSIONAL_CLIENT", Swig_var_PartySubIDType_PROFESSIONAL_CLIENT_get, Swig_var_PartySubIDType_PROFESSIONAL_CLIENT_set);
  SWIG_addvarlink(globals, "PartySubIDType_LOCATION", Swig_var_PartySubIDType_LOCATION_get, Swig_var_PartySubIDType_LOCATION_set);
  SWIG_addvarlink(globals, "PartySubIDType_EXECUTION_VENUE", Swig_var_PartySubIDType_EXECUTION_VENUE_get, Swig_var_PartySubIDType_EXECUTION_VENUE_set);
  SWIG_addvarlink(globals, "PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER", Swig_var_PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER_get, Swig_var_PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER_set);
  SWIG_addvarlink(globals, "PartySubIDType_ADDRESS_CITY", Swig_var_PartySubIDType_ADDRESS_CITY_get, Swig_var_PartySubIDType_ADDRESS_CITY_set);
  SWIG_addvarlink(globals, "PartySubIDType_ADDRESS_STATE_OR_PROVINCE", Swig_var_PartySubIDType_ADDRESS_STATE_OR_PROVINCE_get, Swig_var_PartySubIDType_ADDRESS_STATE_OR_PROVINCE_set);
  SWIG_addvarlink(globals, "PartySubIDType_ADDRESS_POSTAL_CODE", Swig_var_PartySubIDType_ADDRESS_POSTAL_CODE_get, Swig_var_PartySubIDType_ADDRESS_POSTAL_CODE_set);
  SWIG_addvarlink(globals, "PartySubIDType_ADDRESS_STREET", Swig_var_PartySubIDType_ADDRESS_STREET_get, Swig_var_PartySubIDType_ADDRESS_STREET_set);
  SWIG_addvarlink(globals, "PartySubIDType_ADDRESS_ISO_COUNTRY_CODE", Swig_var_PartySubIDType_ADDRESS_ISO_COUNTRY_CODE_get, Swig_var_PartySubIDType_ADDRESS_ISO_COUNTRY_CODE_set);
  SWIG_addvarlink(globals, "PartySubIDType_ISO_COUNTRY_CODE", Swig_var_PartySubIDType_ISO_COUNTRY_CODE_get, Swig_var_PartySubIDType_ISO_COUNTRY_CODE_set);
  SWIG_addvarlink(globals, "PartySubIDType_MARKET_SEGMENT", Swig_var_PartySubIDType_MARKET_SEGMENT_get, Swig_var_PartySubIDType_MARKET_SEGMENT_set);
  SWIG_addvarlink(globals, "PartySubIDType_CUSTOMER_ACCOUNT_TYPE", Swig_var_PartySubIDType_CUSTOMER_ACCOUNT_TYPE_get, Swig_var_PartySubIDType_CUSTOMER_ACCOUNT_TYPE_set);
  SWIG_addvarlink(globals, "PartySubIDType_OMNIBUS_ACCOUNT", Swig_var_PartySubIDType_OMNIBUS_ACCOUNT_get, Swig_var_PartySubIDType_OMNIBUS_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartySubIDType_FUNDS_SEGREGATION_TYPE", Swig_var_PartySubIDType_FUNDS_SEGREGATION_TYPE_get, Swig_var_PartySubIDType_FUNDS_SEGREGATION_TYPE_set);
  SWIG_addvarlink(globals, "PartySubIDType_GUARANTEE_FUND", Swig_var_PartySubIDType_GUARANTEE_FUND_get, Swig_var_PartySubIDType_GUARANTEE_FUND_set);
  SWIG_addvarlink(globals, "PartySubIDType_SWAP_DEALER", Swig_var_PartySubIDType_SWAP_DEALER_get, Swig_var_PartySubIDType_SWAP_DEALER_set);
  SWIG_addvarlink(globals, "PartySubIDType_MAJOR_PARTICIPANT", Swig_var_PartySubIDType_MAJOR_PARTICIPANT_get, Swig_var_PartySubIDType_MAJOR_PARTICIPANT_set);
  SWIG_addvarlink(globals, "PartySubIDType_FINANCIAL_ENTITY", Swig_var_PartySubIDType_FINANCIAL_ENTITY_get, Swig_var_PartySubIDType_FINANCIAL_ENTITY_set);
  SWIG_addvarlink(globals, "PartySubIDType_US_PERSON", Swig_var_PartySubIDType_US_PERSON_get, Swig_var_PartySubIDType_US_PERSON_set);
  SWIG_addvarlink(globals, "PartySubIDType_REPORTING_ENTITY_INDICATOR", Swig_var_PartySubIDType_REPORTING_ENTITY_INDICATOR_get, Swig_var_PartySubIDType_REPORTING_ENTITY_INDICATOR_set);
  SWIG_addvarlink(globals, "PartySubIDType_ELECTED_CLEARING_REQUIREMENT_EXCEPTION", Swig_var_PartySubIDType_ELECTED_CLEARING_REQUIREMENT_EXCEPTION_get, Swig_var_PartySubIDType_ELECTED_CLEARING_REQUIREMENT_EXCEPTION_set);
  SWIG_addvarlink(globals, "PartySubIDType_BUSINESS_CENTER", Swig_var_PartySubIDType_BUSINESS_CENTER_get, Swig_var_PartySubIDType_BUSINESS_CENTER_set);
  SWIG_addvarlink(globals, "PartySubIDType_REFERENCE_TEXT", Swig_var_PartySubIDType_REFERENCE_TEXT_get, Swig_var_PartySubIDType_REFERENCE_TEXT_set);
  SWIG_addvarlink(globals, "PartySubIDType_SHORT_MARKING_EXEMPT_ACCOUNT", Swig_var_PartySubIDType_SHORT_MARKING_EXEMPT_ACCOUNT_get, Swig_var_PartySubIDType_SHORT_MARKING_EXEMPT_ACCOUNT_set);
  SWIG_addvarlink(globals, "PartySubIDType_PARENT_FIRM_IDENTIFIER", Swig_var_PartySubIDType_PARENT_FIRM_IDENTIFIER_get, Swig_var_PartySubIDType_PARENT_FIRM_IDENTIFIER_set);
  SWIG_addvarlink(globals, "PartySubIDType_PARENT_FIRM_NAME", Swig_var_PartySubIDType_PARENT_FIRM_NAME_get, Swig_var_PartySubIDType_PARENT_FIRM_NAME_set);
  SWIG_addvarlink(globals, "PartySubIDType_DEAL_IDENTIFIER", Swig_var_PartySubIDType_DEAL_IDENTIFIER_get, Swig_var_PartySubIDType_DEAL_IDENTIFIER_set);
  SWIG_addvarlink(globals, "PartySubIDType_SYSTEM_TRADE_ID", Swig_var_PartySubIDType_SYSTEM_TRADE_ID_get, Swig_var_PartySubIDType_SYSTEM_TRADE_ID_set);
  SWIG_addvarlink(globals, "PartySubIDType_SYSTEM_TRADE_SUB_ID", Swig_var_PartySubIDType_SYSTEM_TRADE_SUB_ID_get, Swig_var_PartySubIDType_SYSTEM_TRADE_SUB_ID_set);
  SWIG_addvarlink(globals, "PartySubIDType_FCM_CODE", Swig_var_PartySubIDType_FCM_CODE_get, Swig_var_PartySubIDType_FCM_CODE_set);
  SWIG_addvarlink(globals, "PartySubIDType_DLVRY_TRML_CODE", Swig_var_PartySubIDType_DLVRY_TRML_CODE_get, Swig_var_PartySubIDType_DLVRY_TRML_CODE_set);
  SWIG_addvarlink(globals, "PartySubIDType_VOLNTY_RPT_ENTITY", Swig_var_PartySubIDType_VOLNTY_RPT_ENTITY_get, Swig_var_PartySubIDType_VOLNTY_RPT_ENTITY_set);
  SWIG_addvarlink(globals, "PartySubIDType_RPT_OBLIG_JURSDCTN", Swig_var_PartySubIDType_RPT_OBLIG_JURSDCTN_get, Swig_var_PartySubIDType_RPT_OBLIG_JURSDCTN_set);
  SWIG_addvarlink(globals, "PartySubIDType_VOLNTY_RPT_JURSDCTN", Swig_var_PartySubIDType_VOLNTY_RPT_JURSDCTN_get, Swig_var_PartySubIDType_VOLNTY_RPT_JURSDCTN_set);
  SWIG_addvarlink(globals, "PartySubIDType_COMPANY_ACTIVITIES", Swig_var_PartySubIDType_COMPANY_ACTIVITIES_get, Swig_var_PartySubIDType_COMPANY_ACTIVITIES_set);
  SWIG_addvarlink(globals, "PartySubIDType_EE_AREA_DOMICILED", Swig_var_PartySubIDType_EE_AREA_DOMICILED_get, Swig_var_PartySubIDType_EE_AREA_DOMICILED_set);
  SWIG_addvarlink(globals, "PartySubIDType_CONTRACT_LINKED", Swig_var_PartySubIDType_CONTRACT_LINKED_get, Swig_var_PartySubIDType_CONTRACT_LINKED_set);
  SWIG_addvarlink(globals, "PartySubIDType_CONTRACT_ABOVE", Swig_var_PartySubIDType_CONTRACT_ABOVE_get, Swig_var_PartySubIDType_CONTRACT_ABOVE_set);
  SWIG_addvarlink(globals, "PartySubIDType_VOLNTY_RPT_PTY", Swig_var_PartySubIDType_VOLNTY_RPT_PTY_get, Swig_var_PartySubIDType_VOLNTY_RPT_PTY_set);
  SWIG_addvarlink(globals, "PartySubIDType_END_USER", Swig_var_PartySubIDType_END_USER_get, Swig_var_PartySubIDType_END_USER_set);
  SWIG_addvarlink(globals, "PartySubIDType_LOCATION_OR_JURISDICTION", Swig_var_PartySubIDType_LOCATION_OR_JURISDICTION_get, Swig_var_PartySubIDType_LOCATION_OR_JURISDICTION_set);
  SWIG_addvarlink(globals, "PartySubIDType_DERIVATIVES_DEALER", Swig_var_PartySubIDType_DERIVATIVES_DEALER_get, Swig_var_PartySubIDType_DERIVATIVES_DEALER_set);
  SWIG_addvarlink(globals, "PartySubIDType_DOMICILE", Swig_var_PartySubIDType_DOMICILE_get, Swig_var_PartySubIDType_DOMICILE_set);
  SWIG_addvarlink(globals, "PartySubIDType_EXEMPT_FROM_RECOGNITION", Swig_var_PartySubIDType_EXEMPT_FROM_RECOGNITION_get, Swig_var_PartySubIDType_EXEMPT_FROM_RECOGNITION_set);
  SWIG_addvarlink(globals, "PartySubIDType_PAYER", Swig_var_PartySubIDType_PAYER_get, Swig_var_PartySubIDType_PAYER_set);
  SWIG_addvarlink(globals, "PartySubIDType_RECEIVER", Swig_var_PartySubIDType_RECEIVER_get, Swig_var_PartySubIDType_RECEIVER_set);
  SWIG_addvarlink(globals, "PartySubIDType_SYSTEMATIC_INTERNALISER", Swig_var_PartySubIDType_SYSTEMATIC_INTERNALISER_get, Swig_var_PartySubIDType_SYSTEMATIC_INTERNALISER_set);
  SWIG_addvarlink(globals, "PartySubIDType_PUBLISHING_ENTITY_INDICATOR", Swig_var_PartySubIDType_PUBLISHING_ENTITY_INDICATOR_get, Swig_var_PartySubIDType_PUBLISHING_ENTITY_INDICATOR_set);
  SWIG_addvarlink(globals, "PartySubIDType_FIRST_NAME", Swig_var_PartySubIDType_FIRST_NAME_get, Swig_var_PartySubIDType_FIRST_NAME_set);
  SWIG_addvarlink(globals, "PartySubIDType_SURNAME", Swig_var_PartySubIDType_SURNAME_get, Swig_var_PartySubIDType_SURNAME_set);
  SWIG_addvarlink(globals, "PartySubIDType_DATE_OF_BIRTH", Swig_var_PartySubIDType_DATE_OF_BIRTH_get, Swig_var_PartySubIDType_DATE_OF_BIRTH_set);
  SWIG_addvarlink(globals, "PartySubIDType_ORDER_TRANSMITTING_FIRM", Swig_var_PartySubIDType_ORDER_TRANSMITTING_FIRM_get, Swig_var_PartySubIDType_ORDER_TRANSMITTING_FIRM_set);
  SWIG_addvarlink(globals, "PartySubIDType_ORDER_TRANSMITTING_FIRM_BUYER", Swig_var_PartySubIDType_ORDER_TRANSMITTING_FIRM_BUYER_get, Swig_var_PartySubIDType_ORDER_TRANSMITTING_FIRM_BUYER_set);
  SWIG_addvarlink(globals, "PartySubIDType_ORDER_TRANSMITTER_SELLER", Swig_var_PartySubIDType_ORDER_TRANSMITTER_SELLER_get, Swig_var_PartySubIDType_ORDER_TRANSMITTER_SELLER_set);
  SWIG_addvarlink(globals, "PartySubIDType_LEGAL_ENTITY_IDENTIFIER", Swig_var_PartySubIDType_LEGAL_ENTITY_IDENTIFIER_get, Swig_var_PartySubIDType_LEGAL_ENTITY_IDENTIFIER_set);
  SWIG_addvarlink(globals, "PartySubIDType_SUB_SECTOR_CLASSIFICATION", Swig_var_PartySubIDType_SUB_SECTOR_CLASSIFICATION_get, Swig_var_PartySubIDType_SUB_SECTOR_CLASSIFICATION_set);
  SWIG_addvarlink(globals, "PartySubIDType_PARTY_SIDE", Swig_var_PartySubIDType_PARTY_SIDE_get, Swig_var_PartySubIDType_PARTY_SIDE_set);
  SWIG_addvarlink(globals, "PartySubIDType_LEGAL_REGISTRATION_COUNTRY", Swig_var_PartySubIDType_LEGAL_REGISTRATION_COUNTRY_get, Swig_var_PartySubIDType_LEGAL_REGISTRATION_COUNTRY_set);
  SWIG_addvarlink(globals, "AllocIntermedReqType_PENDING_ACCEPT", Swig_var_AllocIntermedReqType_PENDING_ACCEPT_get, Swig_var_AllocIntermedReqType_PENDING_ACCEPT_set);
  SWIG_addvarlink(globals, "AllocIntermedReqType_PENDING_RELEASE", Swig_var_AllocIntermedReqType_PENDING_RELEASE_get, Swig_var_AllocIntermedReqType_PENDING_RELEASE_set);
  SWIG_addvarlink(globals, "AllocIntermedReqType_PENDING_REVERSAL", Swig_var_AllocIntermedReqType_PENDING_REVERSAL_get, Swig_var_AllocIntermedReqType_PENDING_REVERSAL_set);
  SWIG_addvarlink(globals, "AllocIntermedReqType_ACCEPT", Swig_var_AllocIntermedReqType_ACCEPT_get, Swig_var_AllocIntermedReqType_ACCEPT_set);
  SWIG_addvarlink(globals, "AllocIntermedReqType_BLOCK_LEVEL_REJECT", Swig_var_AllocIntermedReqType_BLOCK_LEVEL_REJECT_get, Swig_var_AllocIntermedReqType_BLOCK_LEVEL_REJECT_set);
  SWIG_addvarlink(globals, "AllocIntermedReqType_ACCOUNT_LEVEL_REJECT", Swig_var_AllocIntermedReqType_ACCOUNT_LEVEL_REJECT_get, Swig_var_AllocIntermedReqType_ACCOUNT_LEVEL_REJECT_set);
  SWIG_addvarlink(globals, "ApplQueueResolution_NO_ACTION_TAKEN", Swig_var_ApplQueueResolution_NO_ACTION_TAKEN_get, Swig_var_ApplQueueResolution_NO_ACTION_TAKEN_set);
  SWIG_addvarlink(globals, "ApplQueueResolution_QUEUE_FLUSHED", Swig_var_ApplQueueResolution_QUEUE_FLUSHED_get, Swig_var_ApplQueueResolution_QUEUE_FLUSHED_set);
  SWIG_addvarlink(globals, "ApplQueueResolution_OVERLAY_LAST", Swig_var_ApplQueueResolution_OVERLAY_LAST_get, Swig_var_ApplQueueResolution_OVERLAY_LAST_set);
  SWIG_addvarlink(globals, "ApplQueueResolution_END_SESSION", Swig_var_ApplQueueResolution_END_SESSION_get, Swig_var_ApplQueueResolution_END_SESSION_set);
  SWIG_addvarlink(globals, "ApplQueueAction_NO_ACTION_TAKEN", Swig_var_ApplQueueAction_NO_ACTION_TAKEN_get, Swig_var_ApplQueueAction_NO_ACTION_TAKEN_set);
  SWIG_addvarlink(globals, "ApplQueueAction_QUEUE_FLUSHED", Swig_var_ApplQueueAction_QUEUE_FLUSHED_get, Swig_var_ApplQueueAction_QUEUE_FLUSHED_set);
  SWIG_addvarlink(globals, "ApplQueueAction_OVERLAY_LAST", Swig_var_ApplQueueAction_OVERLAY_LAST_get, Swig_var_ApplQueueAction_OVERLAY_LAST_set);
  SWIG_addvarlink(globals, "ApplQueueAction_END_SESSION", Swig_var_ApplQueueAction_END_SESSION_get, Swig_var_ApplQueueAction_END_SESSION_set);
  SWIG_addvarlink(globals, "AvgPxIndicator_NO_AVERAGE_PRICING", Swig_var_AvgPxIndicator_NO_AVERAGE_PRICING_get, Swig_var_AvgPxIndicator_NO_AVERAGE_PRICING_set);
  SWIG_addvarlink(globals, "AvgPxIndicator_TRADE", Swig_var_AvgPxIndicator_TRADE_get, Swig_var_AvgPxIndicator_TRADE_set);
  SWIG_addvarlink(globals, "AvgPxIndicator_LAST_TRADE", Swig_var_AvgPxIndicator_LAST_TRADE_get, Swig_var_AvgPxIndicator_LAST_TRADE_set);
  SWIG_addvarlink(globals, "AvgPxIndicator_NOTIONAL_VALUE_AVERAGE_PX_GROUP_TRADE", Swig_var_AvgPxIndicator_NOTIONAL_VALUE_AVERAGE_PX_GROUP_TRADE_get, Swig_var_AvgPxIndicator_NOTIONAL_VALUE_AVERAGE_PX_GROUP_TRADE_set);
  SWIG_addvarlink(globals, "AvgPxIndicator_AVERAGE_PRICED_TRADE", Swig_var_AvgPxIndicator_AVERAGE_PRICED_TRADE_get, Swig_var_AvgPxIndicator_AVERAGE_PRICED_TRADE_set);
  SWIG_addvarlink(globals, "TradeAllocIndicator_ALLOCATION_NOT_REQUIRED", Swig_var_TradeAllocIndicator_ALLOCATION_NOT_REQUIRED_get, Swig_var_TradeAllocIndicator_ALLOCATION_NOT_REQUIRED_set);
  SWIG_addvarlink(globals, "TradeAllocIndicator_ALLOCATION_REQUIRED", Swig_var_TradeAllocIndicator_ALLOCATION_REQUIRED_get, Swig_var_TradeAllocIndicator_ALLOCATION_REQUIRED_set);
  SWIG_addvarlink(globals, "TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE", Swig_var_TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE_get, Swig_var_TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE_set);
  SWIG_addvarlink(globals, "TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR", Swig_var_TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR_get, Swig_var_TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR_set);
  SWIG_addvarlink(globals, "TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR", Swig_var_TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR_get, Swig_var_TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR_set);
  SWIG_addvarlink(globals, "TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT", Swig_var_TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT_get, Swig_var_TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT_set);
  SWIG_addvarlink(globals, "TradeAllocIndicator_TRADE_SPLIT", Swig_var_TradeAllocIndicator_TRADE_SPLIT_get, Swig_var_TradeAllocIndicator_TRADE_SPLIT_set);
  SWIG_addvarlink(globals, "ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE", Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE_get, Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE_set);
  SWIG_addvarlink(globals, "ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN", Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN_get, Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN_set);
  SWIG_addvarlink(globals, "ExpirationCycle_SPECIFIED_EXPIRATION", Swig_var_ExpirationCycle_SPECIFIED_EXPIRATION_get, Swig_var_ExpirationCycle_SPECIFIED_EXPIRATION_set);
  SWIG_addvarlink(globals, "TrdType_REGULAR_TRADE", Swig_var_TrdType_REGULAR_TRADE_get, Swig_var_TrdType_REGULAR_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_BLOCK_TRADE", Swig_var_TrdType_BLOCK_TRADE_get, Swig_var_TrdType_BLOCK_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_EFP", Swig_var_TrdType_EFP_get, Swig_var_TrdType_EFP_set);
  SWIG_addvarlink(globals, "TrdType_TRANSFER", Swig_var_TrdType_TRANSFER_get, Swig_var_TrdType_TRANSFER_set);
  SWIG_addvarlink(globals, "TrdType_LATE_TRADE", Swig_var_TrdType_LATE_TRADE_get, Swig_var_TrdType_LATE_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_T_TRADE", Swig_var_TrdType_T_TRADE_get, Swig_var_TrdType_T_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_WEIGHTED_AVERAGE_PRICE_TRADE", Swig_var_TrdType_WEIGHTED_AVERAGE_PRICE_TRADE_get, Swig_var_TrdType_WEIGHTED_AVERAGE_PRICE_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_BUNCHED_TRADE", Swig_var_TrdType_BUNCHED_TRADE_get, Swig_var_TrdType_BUNCHED_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_LATE_BUNCHED_TRADE", Swig_var_TrdType_LATE_BUNCHED_TRADE_get, Swig_var_TrdType_LATE_BUNCHED_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_PRIOR_REFERENCE_PRICE_TRADE", Swig_var_TrdType_PRIOR_REFERENCE_PRICE_TRADE_get, Swig_var_TrdType_PRIOR_REFERENCE_PRICE_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_AFTER_HOURS_TRADE", Swig_var_TrdType_AFTER_HOURS_TRADE_get, Swig_var_TrdType_AFTER_HOURS_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_EXCHANGE_FOR_RISK", Swig_var_TrdType_EXCHANGE_FOR_RISK_get, Swig_var_TrdType_EXCHANGE_FOR_RISK_set);
  SWIG_addvarlink(globals, "TrdType_EXCHANGE_FOR_SWAP", Swig_var_TrdType_EXCHANGE_FOR_SWAP_get, Swig_var_TrdType_EXCHANGE_FOR_SWAP_set);
  SWIG_addvarlink(globals, "TrdType_EXCHANGE_OF_FUTURES_FOR", Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_get, Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_set);
  SWIG_addvarlink(globals, "TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS", Swig_var_TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS_get, Swig_var_TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS_set);
  SWIG_addvarlink(globals, "TrdType_TRADING_AT_SETTLEMENT", Swig_var_TrdType_TRADING_AT_SETTLEMENT_get, Swig_var_TrdType_TRADING_AT_SETTLEMENT_set);
  SWIG_addvarlink(globals, "TrdType_ALL_OR_NONE", Swig_var_TrdType_ALL_OR_NONE_get, Swig_var_TrdType_ALL_OR_NONE_set);
  SWIG_addvarlink(globals, "TrdType_FUTURES_LARGE_ORDER_EXECUTION", Swig_var_TrdType_FUTURES_LARGE_ORDER_EXECUTION_get, Swig_var_TrdType_FUTURES_LARGE_ORDER_EXECUTION_set);
  SWIG_addvarlink(globals, "TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES", Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES_get, Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES_set);
  SWIG_addvarlink(globals, "TrdType_OPTION_INTERIM_TRADE", Swig_var_TrdType_OPTION_INTERIM_TRADE_get, Swig_var_TrdType_OPTION_INTERIM_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_OPTION_CABINET_TRADE", Swig_var_TrdType_OPTION_CABINET_TRADE_get, Swig_var_TrdType_OPTION_CABINET_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_PRIVATELY_NEGOTIATED_TRADES", Swig_var_TrdType_PRIVATELY_NEGOTIATED_TRADES_get, Swig_var_TrdType_PRIVATELY_NEGOTIATED_TRADES_set);
  SWIG_addvarlink(globals, "TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS", Swig_var_TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS_get, Swig_var_TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS_set);
  SWIG_addvarlink(globals, "TrdType_ERROR_TRADE", Swig_var_TrdType_ERROR_TRADE_get, Swig_var_TrdType_ERROR_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_SPECIAL_CUM_DIVIDEND", Swig_var_TrdType_SPECIAL_CUM_DIVIDEND_get, Swig_var_TrdType_SPECIAL_CUM_DIVIDEND_set);
  SWIG_addvarlink(globals, "TrdType_SPECIAL_EX_DIVIDEND", Swig_var_TrdType_SPECIAL_EX_DIVIDEND_get, Swig_var_TrdType_SPECIAL_EX_DIVIDEND_set);
  SWIG_addvarlink(globals, "TrdType_SPECIAL_CUM_COUPON", Swig_var_TrdType_SPECIAL_CUM_COUPON_get, Swig_var_TrdType_SPECIAL_CUM_COUPON_set);
  SWIG_addvarlink(globals, "TrdType_SPECIAL_EX_COUPON", Swig_var_TrdType_SPECIAL_EX_COUPON_get, Swig_var_TrdType_SPECIAL_EX_COUPON_set);
  SWIG_addvarlink(globals, "TrdType_CASH_SETTLEMENT", Swig_var_TrdType_CASH_SETTLEMENT_get, Swig_var_TrdType_CASH_SETTLEMENT_set);
  SWIG_addvarlink(globals, "TrdType_SPECIAL_PRICE", Swig_var_TrdType_SPECIAL_PRICE_get, Swig_var_TrdType_SPECIAL_PRICE_set);
  SWIG_addvarlink(globals, "TrdType_GUARANTEED_DELIVERY", Swig_var_TrdType_GUARANTEED_DELIVERY_get, Swig_var_TrdType_GUARANTEED_DELIVERY_set);
  SWIG_addvarlink(globals, "TrdType_SPECIAL_CUM_RIGHTS", Swig_var_TrdType_SPECIAL_CUM_RIGHTS_get, Swig_var_TrdType_SPECIAL_CUM_RIGHTS_set);
  SWIG_addvarlink(globals, "TrdType_SPECIAL_EX_RIGHTS", Swig_var_TrdType_SPECIAL_EX_RIGHTS_get, Swig_var_TrdType_SPECIAL_EX_RIGHTS_set);
  SWIG_addvarlink(globals, "TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS", Swig_var_TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS_get, Swig_var_TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS_set);
  SWIG_addvarlink(globals, "TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS", Swig_var_TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS_get, Swig_var_TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS_set);
  SWIG_addvarlink(globals, "TrdType_SPECIAL_CUM_BONUS", Swig_var_TrdType_SPECIAL_CUM_BONUS_get, Swig_var_TrdType_SPECIAL_CUM_BONUS_set);
  SWIG_addvarlink(globals, "TrdType_SPECIAL_EX_BONUS", Swig_var_TrdType_SPECIAL_EX_BONUS_get, Swig_var_TrdType_SPECIAL_EX_BONUS_set);
  SWIG_addvarlink(globals, "TrdType_LARGE_TRADE", Swig_var_TrdType_LARGE_TRADE_get, Swig_var_TrdType_LARGE_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_WORKED_PRINCIPAL_TRADE", Swig_var_TrdType_WORKED_PRINCIPAL_TRADE_get, Swig_var_TrdType_WORKED_PRINCIPAL_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_BLOCK_TRADES", Swig_var_TrdType_BLOCK_TRADES_get, Swig_var_TrdType_BLOCK_TRADES_set);
  SWIG_addvarlink(globals, "TrdType_NAME_CHANGE", Swig_var_TrdType_NAME_CHANGE_get, Swig_var_TrdType_NAME_CHANGE_set);
  SWIG_addvarlink(globals, "TrdType_PORTFOLIO_TRANSFER", Swig_var_TrdType_PORTFOLIO_TRANSFER_get, Swig_var_TrdType_PORTFOLIO_TRANSFER_set);
  SWIG_addvarlink(globals, "TrdType_PROROGATION_BUY", Swig_var_TrdType_PROROGATION_BUY_get, Swig_var_TrdType_PROROGATION_BUY_set);
  SWIG_addvarlink(globals, "TrdType_PROROGATION_SELL", Swig_var_TrdType_PROROGATION_SELL_get, Swig_var_TrdType_PROROGATION_SELL_set);
  SWIG_addvarlink(globals, "TrdType_OPTION_EXERCISE", Swig_var_TrdType_OPTION_EXERCISE_get, Swig_var_TrdType_OPTION_EXERCISE_set);
  SWIG_addvarlink(globals, "TrdType_DELTA_NEUTRAL_TRANSACTION", Swig_var_TrdType_DELTA_NEUTRAL_TRANSACTION_get, Swig_var_TrdType_DELTA_NEUTRAL_TRANSACTION_set);
  SWIG_addvarlink(globals, "TrdType_FINANCING_TRANSACTION", Swig_var_TrdType_FINANCING_TRANSACTION_get, Swig_var_TrdType_FINANCING_TRANSACTION_set);
  SWIG_addvarlink(globals, "TrdType_NON_STANDARD_SETTLEMENT", Swig_var_TrdType_NON_STANDARD_SETTLEMENT_get, Swig_var_TrdType_NON_STANDARD_SETTLEMENT_set);
  SWIG_addvarlink(globals, "TrdType_DERIVATIVE_RELATED_TRANSACTION", Swig_var_TrdType_DERIVATIVE_RELATED_TRANSACTION_get, Swig_var_TrdType_DERIVATIVE_RELATED_TRANSACTION_set);
  SWIG_addvarlink(globals, "TrdType_PORTFOLIO_TRADE", Swig_var_TrdType_PORTFOLIO_TRADE_get, Swig_var_TrdType_PORTFOLIO_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE", Swig_var_TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE_get, Swig_var_TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_EXCHANGE_GRANTED_TRADE", Swig_var_TrdType_EXCHANGE_GRANTED_TRADE_get, Swig_var_TrdType_EXCHANGE_GRANTED_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_REPURCHASE_AGREEMENT", Swig_var_TrdType_REPURCHASE_AGREEMENT_get, Swig_var_TrdType_REPURCHASE_AGREEMENT_set);
  SWIG_addvarlink(globals, "TrdType_OTC", Swig_var_TrdType_OTC_get, Swig_var_TrdType_OTC_set);
  SWIG_addvarlink(globals, "TrdType_EXCHANGE_BASIS_FACILITY", Swig_var_TrdType_EXCHANGE_BASIS_FACILITY_get, Swig_var_TrdType_EXCHANGE_BASIS_FACILITY_set);
  SWIG_addvarlink(globals, "TrdType_OPENING_TRADE", Swig_var_TrdType_OPENING_TRADE_get, Swig_var_TrdType_OPENING_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_NETTED_TRADE", Swig_var_TrdType_NETTED_TRADE_get, Swig_var_TrdType_NETTED_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_BLOCK_SWAP_TRADE", Swig_var_TrdType_BLOCK_SWAP_TRADE_get, Swig_var_TrdType_BLOCK_SWAP_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_CREDIT_EVENT_TRADE", Swig_var_TrdType_CREDIT_EVENT_TRADE_get, Swig_var_TrdType_CREDIT_EVENT_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_SUCCESSION_EVENT_TRADE", Swig_var_TrdType_SUCCESSION_EVENT_TRADE_get, Swig_var_TrdType_SUCCESSION_EVENT_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_GIVE_UP_GIVE_IN_TRADE", Swig_var_TrdType_GIVE_UP_GIVE_IN_TRADE_get, Swig_var_TrdType_GIVE_UP_GIVE_IN_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_DARK_TRADE", Swig_var_TrdType_DARK_TRADE_get, Swig_var_TrdType_DARK_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_TECHNICAL_TRADE", Swig_var_TrdType_TECHNICAL_TRADE_get, Swig_var_TrdType_TECHNICAL_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_BENCHMARK", Swig_var_TrdType_BENCHMARK_get, Swig_var_TrdType_BENCHMARK_set);
  SWIG_addvarlink(globals, "TrdType_PACKAGE_TRADE", Swig_var_TrdType_PACKAGE_TRADE_get, Swig_var_TrdType_PACKAGE_TRADE_set);
  SWIG_addvarlink(globals, "TrdType_ROLL_TRADE", Swig_var_TrdType_ROLL_TRADE_get, Swig_var_TrdType_ROLL_TRADE_set);
  SWIG_addvarlink(globals, "TrdSubType_CMTA", Swig_var_TrdSubType_CMTA_get, Swig_var_TrdSubType_CMTA_set);
  SWIG_addvarlink(globals, "TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT", Swig_var_TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT_get, Swig_var_TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT_set);
  SWIG_addvarlink(globals, "TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT", Swig_var_TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT_get, Swig_var_TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT_set);
  SWIG_addvarlink(globals, "TrdSubType_REJECT_FOR_SUBMITTING_SIDE", Swig_var_TrdSubType_REJECT_FOR_SUBMITTING_SIDE_get, Swig_var_TrdSubType_REJECT_FOR_SUBMITTING_SIDE_set);
  SWIG_addvarlink(globals, "TrdSubType_ADVISORY_FOR_CONTRA_SIDE", Swig_var_TrdSubType_ADVISORY_FOR_CONTRA_SIDE_get, Swig_var_TrdSubType_ADVISORY_FOR_CONTRA_SIDE_set);
  SWIG_addvarlink(globals, "TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION", Swig_var_TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION_get, Swig_var_TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION_set);
  SWIG_addvarlink(globals, "TrdSubType_ONSET_DUE_TO_AN_ALLOCATION", Swig_var_TrdSubType_ONSET_DUE_TO_AN_ALLOCATION_get, Swig_var_TrdSubType_ONSET_DUE_TO_AN_ALLOCATION_set);
  SWIG_addvarlink(globals, "TrdSubType_DIFFERENTIAL_SPREAD", Swig_var_TrdSubType_DIFFERENTIAL_SPREAD_get, Swig_var_TrdSubType_DIFFERENTIAL_SPREAD_set);
  SWIG_addvarlink(globals, "TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT", Swig_var_TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_get, Swig_var_TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_set);
  SWIG_addvarlink(globals, "TrdSubType_TRANSACTION_FROM_EXERCISE", Swig_var_TrdSubType_TRANSACTION_FROM_EXERCISE_get, Swig_var_TrdSubType_TRANSACTION_FROM_EXERCISE_set);
  SWIG_addvarlink(globals, "TrdSubType_TRANSACTION_FROM_ASSIGNMENT", Swig_var_TrdSubType_TRANSACTION_FROM_ASSIGNMENT_get, Swig_var_TrdSubType_TRANSACTION_FROM_ASSIGNMENT_set);
  SWIG_addvarlink(globals, "TrdSubType_ACATS", Swig_var_TrdSubType_ACATS_get, Swig_var_TrdSubType_ACATS_set);
  SWIG_addvarlink(globals, "TrdSubType_AI", Swig_var_TrdSubType_AI_get, Swig_var_TrdSubType_AI_set);
  SWIG_addvarlink(globals, "TrdSubType_B", Swig_var_TrdSubType_B_get, Swig_var_TrdSubType_B_set);
  SWIG_addvarlink(globals, "TrdSubType_K", Swig_var_TrdSubType_K_get, Swig_var_TrdSubType_K_set);
  SWIG_addvarlink(globals, "TrdSubType_LC", Swig_var_TrdSubType_LC_get, Swig_var_TrdSubType_LC_set);
  SWIG_addvarlink(globals, "TrdSubType_M", Swig_var_TrdSubType_M_get, Swig_var_TrdSubType_M_set);
  SWIG_addvarlink(globals, "TrdSubType_N", Swig_var_TrdSubType_N_get, Swig_var_TrdSubType_N_set);
  SWIG_addvarlink(globals, "TrdSubType_NM", Swig_var_TrdSubType_NM_get, Swig_var_TrdSubType_NM_set);
  SWIG_addvarlink(globals, "TrdSubType_NR", Swig_var_TrdSubType_NR_get, Swig_var_TrdSubType_NR_set);
  SWIG_addvarlink(globals, "TrdSubType_P", Swig_var_TrdSubType_P_get, Swig_var_TrdSubType_P_set);
  SWIG_addvarlink(globals, "TrdSubType_PA", Swig_var_TrdSubType_PA_get, Swig_var_TrdSubType_PA_set);
  SWIG_addvarlink(globals, "TrdSubType_PC", Swig_var_TrdSubType_PC_get, Swig_var_TrdSubType_PC_set);
  SWIG_addvarlink(globals, "TrdSubType_PN", Swig_var_TrdSubType_PN_get, Swig_var_TrdSubType_PN_set);
  SWIG_addvarlink(globals, "TrdSubType_R", Swig_var_TrdSubType_R_get, Swig_var_TrdSubType_R_set);
  SWIG_addvarlink(globals, "TrdSubType_RO", Swig_var_TrdSubType_RO_get, Swig_var_TrdSubType_RO_set);
  SWIG_addvarlink(globals, "TrdSubType_RT", Swig_var_TrdSubType_RT_get, Swig_var_TrdSubType_RT_set);
  SWIG_addvarlink(globals, "TrdSubType_SW", Swig_var_TrdSubType_SW_get, Swig_var_TrdSubType_SW_set);
  SWIG_addvarlink(globals, "TrdSubType_T", Swig_var_TrdSubType_T_get, Swig_var_TrdSubType_T_set);
  SWIG_addvarlink(globals, "TrdSubType_WN", Swig_var_TrdSubType_WN_get, Swig_var_TrdSubType_WN_set);
  SWIG_addvarlink(globals, "TrdSubType_WT", Swig_var_TrdSubType_WT_get, Swig_var_TrdSubType_WT_set);
  SWIG_addvarlink(globals, "TrdSubType_OFF_HOURS_TRADE", Swig_var_TrdSubType_OFF_HOURS_TRADE_get, Swig_var_TrdSubType_OFF_HOURS_TRADE_set);
  SWIG_addvarlink(globals, "TrdSubType_ON_HOURS_TRADE", Swig_var_TrdSubType_ON_HOURS_TRADE_get, Swig_var_TrdSubType_ON_HOURS_TRADE_set);
  SWIG_addvarlink(globals, "TrdSubType_OTC_QUOTE", Swig_var_TrdSubType_OTC_QUOTE_get, Swig_var_TrdSubType_OTC_QUOTE_set);
  SWIG_addvarlink(globals, "TrdSubType_CONVERTED_SWAP", Swig_var_TrdSubType_CONVERTED_SWAP_get, Swig_var_TrdSubType_CONVERTED_SWAP_set);
  SWIG_addvarlink(globals, "TrdSubType_CROSSED_TRADE", Swig_var_TrdSubType_CROSSED_TRADE_get, Swig_var_TrdSubType_CROSSED_TRADE_set);
  SWIG_addvarlink(globals, "TrdSubType_INTERIM_PROTECTED_TRADE", Swig_var_TrdSubType_INTERIM_PROTECTED_TRADE_get, Swig_var_TrdSubType_INTERIM_PROTECTED_TRADE_set);
  SWIG_addvarlink(globals, "TrdSubType_LARGE_IN_SCALE", Swig_var_TrdSubType_LARGE_IN_SCALE_get, Swig_var_TrdSubType_LARGE_IN_SCALE_set);
  SWIG_addvarlink(globals, "TrdSubType_WASH_TRADE", Swig_var_TrdSubType_WASH_TRADE_get, Swig_var_TrdSubType_WASH_TRADE_set);
  SWIG_addvarlink(globals, "TrdSubType_TRADE_AT_SETTLEMENT", Swig_var_TrdSubType_TRADE_AT_SETTLEMENT_get, Swig_var_TrdSubType_TRADE_AT_SETTLEMENT_set);
  SWIG_addvarlink(globals, "TrdSubType_AUCTION_TRADE", Swig_var_TrdSubType_AUCTION_TRADE_get, Swig_var_TrdSubType_AUCTION_TRADE_set);
  SWIG_addvarlink(globals, "TrdSubType_TRADE_AT_MARKER", Swig_var_TrdSubType_TRADE_AT_MARKER_get, Swig_var_TrdSubType_TRADE_AT_MARKER_set);
  SWIG_addvarlink(globals, "TrdSubType_CREDIT_DEFAULT", Swig_var_TrdSubType_CREDIT_DEFAULT_get, Swig_var_TrdSubType_CREDIT_DEFAULT_set);
  SWIG_addvarlink(globals, "TrdSubType_CREDIT_RESTRUCTURING", Swig_var_TrdSubType_CREDIT_RESTRUCTURING_get, Swig_var_TrdSubType_CREDIT_RESTRUCTURING_set);
  SWIG_addvarlink(globals, "TrdSubType_MERGER", Swig_var_TrdSubType_MERGER_get, Swig_var_TrdSubType_MERGER_set);
  SWIG_addvarlink(globals, "TrdSubType_SPIN_OFF", Swig_var_TrdSubType_SPIN_OFF_get, Swig_var_TrdSubType_SPIN_OFF_set);
  SWIG_addvarlink(globals, "TrdSubType_MULTILATERAL_COMPRESSION", Swig_var_TrdSubType_MULTILATERAL_COMPRESSION_get, Swig_var_TrdSubType_MULTILATERAL_COMPRESSION_set);
  SWIG_addvarlink(globals, "TrdSubType_BALANCING", Swig_var_TrdSubType_BALANCING_get, Swig_var_TrdSubType_BALANCING_set);
  SWIG_addvarlink(globals, "TrdSubType_BASIS_TRADE_INDEX_CLOSE", Swig_var_TrdSubType_BASIS_TRADE_INDEX_CLOSE_get, Swig_var_TrdSubType_BASIS_TRADE_INDEX_CLOSE_set);
  SWIG_addvarlink(globals, "TrdSubType_TRADE_AT_CASH_OPEN", Swig_var_TrdSubType_TRADE_AT_CASH_OPEN_get, Swig_var_TrdSubType_TRADE_AT_CASH_OPEN_set);
  SWIG_addvarlink(globals, "TrdSubType_TRD_SUBMIT_VENUE_CLR_SETTL", Swig_var_TrdSubType_TRD_SUBMIT_VENUE_CLR_SETTL_get, Swig_var_TrdSubType_TRD_SUBMIT_VENUE_CLR_SETTL_set);
  SWIG_addvarlink(globals, "TrdSubType_BILATERAL_COMPRESSION", Swig_var_TrdSubType_BILATERAL_COMPRESSION_get, Swig_var_TrdSubType_BILATERAL_COMPRESSION_set);
  SWIG_addvarlink(globals, "PegMoveType_FLOATING", Swig_var_PegMoveType_FLOATING_get, Swig_var_PegMoveType_FLOATING_set);
  SWIG_addvarlink(globals, "PegMoveType_FIXED", Swig_var_PegMoveType_FIXED_get, Swig_var_PegMoveType_FIXED_set);
  SWIG_addvarlink(globals, "PegOffsetType_PRICE", Swig_var_PegOffsetType_PRICE_get, Swig_var_PegOffsetType_PRICE_set);
  SWIG_addvarlink(globals, "PegOffsetType_BASIS_POINTS", Swig_var_PegOffsetType_BASIS_POINTS_get, Swig_var_PegOffsetType_BASIS_POINTS_set);
  SWIG_addvarlink(globals, "PegOffsetType_TICKS", Swig_var_PegOffsetType_TICKS_get, Swig_var_PegOffsetType_TICKS_set);
  SWIG_addvarlink(globals, "PegOffsetType_PRICE_TIER", Swig_var_PegOffsetType_PRICE_TIER_get, Swig_var_PegOffsetType_PRICE_TIER_set);
  SWIG_addvarlink(globals, "PegOffsetType_PERCENTAGE", Swig_var_PegOffsetType_PERCENTAGE_get, Swig_var_PegOffsetType_PERCENTAGE_set);
  SWIG_addvarlink(globals, "PegLimitType_OR_BETTER", Swig_var_PegLimitType_OR_BETTER_get, Swig_var_PegLimitType_OR_BETTER_set);
  SWIG_addvarlink(globals, "PegLimitType_STRICT", Swig_var_PegLimitType_STRICT_get, Swig_var_PegLimitType_STRICT_set);
  SWIG_addvarlink(globals, "PegLimitType_OR_WORSE", Swig_var_PegLimitType_OR_WORSE_get, Swig_var_PegLimitType_OR_WORSE_set);
  SWIG_addvarlink(globals, "PegRoundDirection_MORE_AGGRESSIVE", Swig_var_PegRoundDirection_MORE_AGGRESSIVE_get, Swig_var_PegRoundDirection_MORE_AGGRESSIVE_set);
  SWIG_addvarlink(globals, "PegRoundDirection_MORE_PASSIVE", Swig_var_PegRoundDirection_MORE_PASSIVE_get, Swig_var_PegRoundDirection_MORE_PASSIVE_set);
  SWIG_addvarlink(globals, "PegScope_LOCAL", Swig_var_PegScope_LOCAL_get, Swig_var_PegScope_LOCAL_set);
  SWIG_addvarlink(globals, "PegScope_NATIONAL", Swig_var_PegScope_NATIONAL_get, Swig_var_PegScope_NATIONAL_set);
  SWIG_addvarlink(globals, "PegScope_GLOBAL", Swig_var_PegScope_GLOBAL_get, Swig_var_PegScope_GLOBAL_set);
  SWIG_addvarlink(globals, "PegScope_NATIONAL_EXCLUDING_LOCAL", Swig_var_PegScope_NATIONAL_EXCLUDING_LOCAL_get, Swig_var_PegScope_NATIONAL_EXCLUDING_LOCAL_set);
  SWIG_addvarlink(globals, "DiscretionMoveType_FLOATING", Swig_var_DiscretionMoveType_FLOATING_get, Swig_var_DiscretionMoveType_FLOATING_set);
  SWIG_addvarlink(globals, "DiscretionMoveType_FIXED", Swig_var_DiscretionMoveType_FIXED_get, Swig_var_DiscretionMoveType_FIXED_set);
  SWIG_addvarlink(globals, "DiscretionOffsetType_PRICE", Swig_var_DiscretionOffsetType_PRICE_get, Swig_var_DiscretionOffsetType_PRICE_set);
  SWIG_addvarlink(globals, "DiscretionOffsetType_BASIS_POINTS", Swig_var_DiscretionOffsetType_BASIS_POINTS_get, Swig_var_DiscretionOffsetType_BASIS_POINTS_set);
  SWIG_addvarlink(globals, "DiscretionOffsetType_TICKS", Swig_var_DiscretionOffsetType_TICKS_get, Swig_var_DiscretionOffsetType_TICKS_set);
  SWIG_addvarlink(globals, "DiscretionOffsetType_PRICE_TIER", Swig_var_DiscretionOffsetType_PRICE_TIER_get, Swig_var_DiscretionOffsetType_PRICE_TIER_set);
  SWIG_addvarlink(globals, "DiscretionLimitType_OR_BETTER", Swig_var_DiscretionLimitType_OR_BETTER_get, Swig_var_DiscretionLimitType_OR_BETTER_set);
  SWIG_addvarlink(globals, "DiscretionLimitType_STRICT", Swig_var_DiscretionLimitType_STRICT_get, Swig_var_DiscretionLimitType_STRICT_set);
  SWIG_addvarlink(globals, "DiscretionLimitType_OR_WORSE", Swig_var_DiscretionLimitType_OR_WORSE_get, Swig_var_DiscretionLimitType_OR_WORSE_set);
  SWIG_addvarlink(globals, "DiscretionRoundDirection_MORE_AGGRESSIVE", Swig_var_DiscretionRoundDirection_MORE_AGGRESSIVE_get, Swig_var_DiscretionRoundDirection_MORE_AGGRESSIVE_set);
  SWIG_addvarlink(globals, "DiscretionRoundDirection_MORE_PASSIVE", Swig_var_DiscretionRoundDirection_MORE_PASSIVE_get, Swig_var_DiscretionRoundDirection_MORE_PASSIVE_set);
  SWIG_addvarlink(globals, "DiscretionScope_LOCAL", Swig_var_DiscretionScope_LOCAL_get, Swig_var_DiscretionScope_LOCAL_set);
  SWIG_addvarlink(globals, "DiscretionScope_NATIONAL", Swig_var_DiscretionScope_NATIONAL_get, Swig_var_DiscretionScope_NATIONAL_set);
  SWIG_addvarlink(globals, "DiscretionScope_GLOBAL", Swig_var_DiscretionScope_GLOBAL_get, Swig_var_DiscretionScope_GLOBAL_set);
  SWIG_addvarlink(globals, "DiscretionScope_NATIONAL_EXCLUDING_LOCAL", Swig_var_DiscretionScope_NATIONAL_EXCLUDING_LOCAL_get, Swig_var_DiscretionScope_NATIONAL_EXCLUDING_LOCAL_set);
  SWIG_addvarlink(globals, "TargetStrategy_VWAP", Swig_var_TargetStrategy_VWAP_get, Swig_var_TargetStrategy_VWAP_set);
  SWIG_addvarlink(globals, "TargetStrategy_PARTICIPATE", Swig_var_TargetStrategy_PARTICIPATE_get, Swig_var_TargetStrategy_PARTICIPATE_set);
  SWIG_addvarlink(globals, "TargetStrategy_MININIZE_MARKET_IMPACT", Swig_var_TargetStrategy_MININIZE_MARKET_IMPACT_get, Swig_var_TargetStrategy_MININIZE_MARKET_IMPACT_set);
  SWIG_addvarlink(globals, "LastLiquidityInd_ADDED_LIQUIDITY", Swig_var_LastLiquidityInd_ADDED_LIQUIDITY_get, Swig_var_LastLiquidityInd_ADDED_LIQUIDITY_set);
  SWIG_addvarlink(globals, "LastLiquidityInd_REMOVED_LIQUIDITY", Swig_var_LastLiquidityInd_REMOVED_LIQUIDITY_get, Swig_var_LastLiquidityInd_REMOVED_LIQUIDITY_set);
  SWIG_addvarlink(globals, "LastLiquidityInd_LIQUIDITY_ROUTED_OUT", Swig_var_LastLiquidityInd_LIQUIDITY_ROUTED_OUT_get, Swig_var_LastLiquidityInd_LIQUIDITY_ROUTED_OUT_set);
  SWIG_addvarlink(globals, "LastLiquidityInd_AUCTION", Swig_var_LastLiquidityInd_AUCTION_get, Swig_var_LastLiquidityInd_AUCTION_set);
  SWIG_addvarlink(globals, "LastLiquidityInd_NEITHER_ADDED_NOR_REMOVED_LIQUIDITY", Swig_var_LastLiquidityInd_NEITHER_ADDED_NOR_REMOVED_LIQUIDITY_get, Swig_var_LastLiquidityInd_NEITHER_ADDED_NOR_REMOVED_LIQUIDITY_set);
  SWIG_addvarlink(globals, "LastLiquidityInd_TRIGGERED_STOP_ORDER", Swig_var_LastLiquidityInd_TRIGGERED_STOP_ORDER_get, Swig_var_LastLiquidityInd_TRIGGERED_STOP_ORDER_set);
  SWIG_addvarlink(globals, "LastLiquidityInd_TRIGGERED_CONTINGENCY_ORDER", Swig_var_LastLiquidityInd_TRIGGERED_CONTINGENCY_ORDER_get, Swig_var_LastLiquidityInd_TRIGGERED_CONTINGENCY_ORDER_set);
  SWIG_addvarlink(globals, "LastLiquidityInd_TRIGGERED_MARKET_ORDER", Swig_var_LastLiquidityInd_TRIGGERED_MARKET_ORDER_get, Swig_var_LastLiquidityInd_TRIGGERED_MARKET_ORDER_set);
  SWIG_addvarlink(globals, "LastLiquidityInd_REMOVED_LIQUIDITY_AFTER_FIRM_ORDER_COMMITMENT", Swig_var_LastLiquidityInd_REMOVED_LIQUIDITY_AFTER_FIRM_ORDER_COMMITMENT_get, Swig_var_LastLiquidityInd_REMOVED_LIQUIDITY_AFTER_FIRM_ORDER_COMMITMENT_set);
  SWIG_addvarlink(globals, "LastLiquidityInd_AUCTION_EXECUTION_AFTER_FIRM_ORDER_COMMITMENT", Swig_var_LastLiquidityInd_AUCTION_EXECUTION_AFTER_FIRM_ORDER_COMMITMENT_get, Swig_var_LastLiquidityInd_AUCTION_EXECUTION_AFTER_FIRM_ORDER_COMMITMENT_set);
  SWIG_addvarlink(globals, "LastLiquidityInd_UNKNOWN", Swig_var_LastLiquidityInd_UNKNOWN_get, Swig_var_LastLiquidityInd_UNKNOWN_set);
  SWIG_addvarlink(globals, "LastLiquidityInd_OTHER", Swig_var_LastLiquidityInd_OTHER_get, Swig_var_LastLiquidityInd_OTHER_set);
  SWIG_addvarlink(globals, "PublishTrdIndicator_YES", Swig_var_PublishTrdIndicator_YES_get, Swig_var_PublishTrdIndicator_YES_set);
  SWIG_addvarlink(globals, "PublishTrdIndicator_NO", Swig_var_PublishTrdIndicator_NO_get, Swig_var_PublishTrdIndicator_NO_set);
  SWIG_addvarlink(globals, "ShortSaleReason_DEALER_SOLD_SHORT", Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_get, Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_set);
  SWIG_addvarlink(globals, "ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT", Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT_get, Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT_set);
  SWIG_addvarlink(globals, "ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT", Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_get, Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_set);
  SWIG_addvarlink(globals, "ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT", Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT_get, Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT_set);
  SWIG_addvarlink(globals, "ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE", Swig_var_ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE_get, Swig_var_ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE_set);
  SWIG_addvarlink(globals, "ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT", Swig_var_ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT_get, Swig_var_ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT_set);
  SWIG_addvarlink(globals, "QtyType_UNITS", Swig_var_QtyType_UNITS_get, Swig_var_QtyType_UNITS_set);
  SWIG_addvarlink(globals, "QtyType_CONTRACTS", Swig_var_QtyType_CONTRACTS_get, Swig_var_QtyType_CONTRACTS_set);
  SWIG_addvarlink(globals, "QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT", Swig_var_QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT_get, Swig_var_QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT_set);
  SWIG_addvarlink(globals, "TradeReportType_SUBMIT", Swig_var_TradeReportType_SUBMIT_get, Swig_var_TradeReportType_SUBMIT_set);
  SWIG_addvarlink(globals, "TradeReportType_ALLEGED", Swig_var_TradeReportType_ALLEGED_get, Swig_var_TradeReportType_ALLEGED_set);
  SWIG_addvarlink(globals, "TradeReportType_ACCEPT", Swig_var_TradeReportType_ACCEPT_get, Swig_var_TradeReportType_ACCEPT_set);
  SWIG_addvarlink(globals, "TradeReportType_DECLINE", Swig_var_TradeReportType_DECLINE_get, Swig_var_TradeReportType_DECLINE_set);
  SWIG_addvarlink(globals, "TradeReportType_ADDENDUM", Swig_var_TradeReportType_ADDENDUM_get, Swig_var_TradeReportType_ADDENDUM_set);
  SWIG_addvarlink(globals, "TradeReportType_NO", Swig_var_TradeReportType_NO_get, Swig_var_TradeReportType_NO_set);
  SWIG_addvarlink(globals, "TradeReportType_TRADE_REPORT_CANCEL", Swig_var_TradeReportType_TRADE_REPORT_CANCEL_get, Swig_var_TradeReportType_TRADE_REPORT_CANCEL_set);
  SWIG_addvarlink(globals, "TradeReportType_LOCKED_IN", Swig_var_TradeReportType_LOCKED_IN_get, Swig_var_TradeReportType_LOCKED_IN_set);
  SWIG_addvarlink(globals, "TradeReportType_DEFAULTED", Swig_var_TradeReportType_DEFAULTED_get, Swig_var_TradeReportType_DEFAULTED_set);
  SWIG_addvarlink(globals, "TradeReportType_INVALID_CMTA", Swig_var_TradeReportType_INVALID_CMTA_get, Swig_var_TradeReportType_INVALID_CMTA_set);
  SWIG_addvarlink(globals, "TradeReportType_PENDED", Swig_var_TradeReportType_PENDED_get, Swig_var_TradeReportType_PENDED_set);
  SWIG_addvarlink(globals, "TradeReportType_ALLEGED_NEW", Swig_var_TradeReportType_ALLEGED_NEW_get, Swig_var_TradeReportType_ALLEGED_NEW_set);
  SWIG_addvarlink(globals, "TradeReportType_ALLEGED_ADDENDUM", Swig_var_TradeReportType_ALLEGED_ADDENDUM_get, Swig_var_TradeReportType_ALLEGED_ADDENDUM_set);
  SWIG_addvarlink(globals, "TradeReportType_ALLEGED_NO", Swig_var_TradeReportType_ALLEGED_NO_get, Swig_var_TradeReportType_ALLEGED_NO_set);
  SWIG_addvarlink(globals, "TradeReportType_ALLEGED_TRADE_REPORT_CANCEL", Swig_var_TradeReportType_ALLEGED_TRADE_REPORT_CANCEL_get, Swig_var_TradeReportType_ALLEGED_TRADE_REPORT_CANCEL_set);
  SWIG_addvarlink(globals, "TradeReportType_ALLEGED_TRADE_BREAK", Swig_var_TradeReportType_ALLEGED_TRADE_BREAK_get, Swig_var_TradeReportType_ALLEGED_TRADE_BREAK_set);
  SWIG_addvarlink(globals, "TradeReportType_VERIFY", Swig_var_TradeReportType_VERIFY_get, Swig_var_TradeReportType_VERIFY_set);
  SWIG_addvarlink(globals, "TradeReportType_DISPUTE", Swig_var_TradeReportType_DISPUTE_get, Swig_var_TradeReportType_DISPUTE_set);
  SWIG_addvarlink(globals, "TradeReportType_NON_MATERIAL_UPDATE", Swig_var_TradeReportType_NON_MATERIAL_UPDATE_get, Swig_var_TradeReportType_NON_MATERIAL_UPDATE_set);
  SWIG_addvarlink(globals, "AllocNoOrdersType_NOT_SPECIFIED", Swig_var_AllocNoOrdersType_NOT_SPECIFIED_get, Swig_var_AllocNoOrdersType_NOT_SPECIFIED_set);
  SWIG_addvarlink(globals, "AllocNoOrdersType_EXPLICIT_LIST_PROVIDED", Swig_var_AllocNoOrdersType_EXPLICIT_LIST_PROVIDED_get, Swig_var_AllocNoOrdersType_EXPLICIT_LIST_PROVIDED_set);
  SWIG_addvarlink(globals, "EventType_PUT", Swig_var_EventType_PUT_get, Swig_var_EventType_PUT_set);
  SWIG_addvarlink(globals, "EventType_CALL", Swig_var_EventType_CALL_get, Swig_var_EventType_CALL_set);
  SWIG_addvarlink(globals, "EventType_TENDER", Swig_var_EventType_TENDER_get, Swig_var_EventType_TENDER_set);
  SWIG_addvarlink(globals, "EventType_SINKING_FUND_CALL", Swig_var_EventType_SINKING_FUND_CALL_get, Swig_var_EventType_SINKING_FUND_CALL_set);
  SWIG_addvarlink(globals, "EventType_OTHER", Swig_var_EventType_OTHER_get, Swig_var_EventType_OTHER_set);
  SWIG_addvarlink(globals, "EventType_ACTIVATION", Swig_var_EventType_ACTIVATION_get, Swig_var_EventType_ACTIVATION_set);
  SWIG_addvarlink(globals, "EventType_INACTIVIATION", Swig_var_EventType_INACTIVIATION_get, Swig_var_EventType_INACTIVIATION_set);
  SWIG_addvarlink(globals, "EventType_LAST_ELIGIBLE_TRADE_DATE", Swig_var_EventType_LAST_ELIGIBLE_TRADE_DATE_get, Swig_var_EventType_LAST_ELIGIBLE_TRADE_DATE_set);
  SWIG_addvarlink(globals, "EventType_SWAP_START_DATE", Swig_var_EventType_SWAP_START_DATE_get, Swig_var_EventType_SWAP_START_DATE_set);
  SWIG_addvarlink(globals, "EventType_SWAP_END_DATE", Swig_var_EventType_SWAP_END_DATE_get, Swig_var_EventType_SWAP_END_DATE_set);
  SWIG_addvarlink(globals, "EventType_SWAP_ROLL_DATE", Swig_var_EventType_SWAP_ROLL_DATE_get, Swig_var_EventType_SWAP_ROLL_DATE_set);
  SWIG_addvarlink(globals, "EventType_SWAP_NEXT_START_DATE", Swig_var_EventType_SWAP_NEXT_START_DATE_get, Swig_var_EventType_SWAP_NEXT_START_DATE_set);
  SWIG_addvarlink(globals, "EventType_SWAP_NEXT_ROLL_DATE", Swig_var_EventType_SWAP_NEXT_ROLL_DATE_get, Swig_var_EventType_SWAP_NEXT_ROLL_DATE_set);
  SWIG_addvarlink(globals, "EventType_FIRST_DELIVERY_DATE", Swig_var_EventType_FIRST_DELIVERY_DATE_get, Swig_var_EventType_FIRST_DELIVERY_DATE_set);
  SWIG_addvarlink(globals, "EventType_LAST_DELIVERY_DATE", Swig_var_EventType_LAST_DELIVERY_DATE_get, Swig_var_EventType_LAST_DELIVERY_DATE_set);
  SWIG_addvarlink(globals, "EventType_INITIAL_INVENTORY_DUE_DATE", Swig_var_EventType_INITIAL_INVENTORY_DUE_DATE_get, Swig_var_EventType_INITIAL_INVENTORY_DUE_DATE_set);
  SWIG_addvarlink(globals, "EventType_FINAL_INVENTORY_DUE_DATE", Swig_var_EventType_FINAL_INVENTORY_DUE_DATE_get, Swig_var_EventType_FINAL_INVENTORY_DUE_DATE_set);
  SWIG_addvarlink(globals, "EventType_FIRST_INTENT_DATE", Swig_var_EventType_FIRST_INTENT_DATE_get, Swig_var_EventType_FIRST_INTENT_DATE_set);
  SWIG_addvarlink(globals, "EventType_LAST_INTENT_DATE", Swig_var_EventType_LAST_INTENT_DATE_get, Swig_var_EventType_LAST_INTENT_DATE_set);
  SWIG_addvarlink(globals, "EventType_POSITION_REMOVAL_DATE", Swig_var_EventType_POSITION_REMOVAL_DATE_get, Swig_var_EventType_POSITION_REMOVAL_DATE_set);
  SWIG_addvarlink(globals, "EventType_MINIMUM_NOTICE", Swig_var_EventType_MINIMUM_NOTICE_get, Swig_var_EventType_MINIMUM_NOTICE_set);
  SWIG_addvarlink(globals, "EventType_DELIVERY_START_TIME", Swig_var_EventType_DELIVERY_START_TIME_get, Swig_var_EventType_DELIVERY_START_TIME_set);
  SWIG_addvarlink(globals, "EventType_DELIVERY_END_TIME", Swig_var_EventType_DELIVERY_END_TIME_get, Swig_var_EventType_DELIVERY_END_TIME_set);
  SWIG_addvarlink(globals, "EventType_FIRST_NOTICE_DATE", Swig_var_EventType_FIRST_NOTICE_DATE_get, Swig_var_EventType_FIRST_NOTICE_DATE_set);
  SWIG_addvarlink(globals, "EventType_LAST_NOTICE_DATE", Swig_var_EventType_LAST_NOTICE_DATE_get, Swig_var_EventType_LAST_NOTICE_DATE_set);
  SWIG_addvarlink(globals, "EventType_FIRST_EXERCISE_DATE", Swig_var_EventType_FIRST_EXERCISE_DATE_get, Swig_var_EventType_FIRST_EXERCISE_DATE_set);
  SWIG_addvarlink(globals, "EventType_REDEMPTION_DATE", Swig_var_EventType_REDEMPTION_DATE_get, Swig_var_EventType_REDEMPTION_DATE_set);
  SWIG_addvarlink(globals, "EventType_TRD_CNTNTN_EFCTV_DT", Swig_var_EventType_TRD_CNTNTN_EFCTV_DT_get, Swig_var_EventType_TRD_CNTNTN_EFCTV_DT_set);
  SWIG_addvarlink(globals, "InstrAttribType_FLAT", Swig_var_InstrAttribType_FLAT_get, Swig_var_InstrAttribType_FLAT_set);
  SWIG_addvarlink(globals, "InstrAttribType_ZERO_COUPON", Swig_var_InstrAttribType_ZERO_COUPON_get, Swig_var_InstrAttribType_ZERO_COUPON_set);
  SWIG_addvarlink(globals, "InstrAttribType_INTEREST_BEARING", Swig_var_InstrAttribType_INTEREST_BEARING_get, Swig_var_InstrAttribType_INTEREST_BEARING_set);
  SWIG_addvarlink(globals, "InstrAttribType_NO_PERIODIC_PAYMENTS", Swig_var_InstrAttribType_NO_PERIODIC_PAYMENTS_get, Swig_var_InstrAttribType_NO_PERIODIC_PAYMENTS_set);
  SWIG_addvarlink(globals, "InstrAttribType_VARIABLE_RATE", Swig_var_InstrAttribType_VARIABLE_RATE_get, Swig_var_InstrAttribType_VARIABLE_RATE_set);
  SWIG_addvarlink(globals, "InstrAttribType_LESS_FEE_FOR_PUT", Swig_var_InstrAttribType_LESS_FEE_FOR_PUT_get, Swig_var_InstrAttribType_LESS_FEE_FOR_PUT_set);
  SWIG_addvarlink(globals, "InstrAttribType_STEPPED_COUPON", Swig_var_InstrAttribType_STEPPED_COUPON_get, Swig_var_InstrAttribType_STEPPED_COUPON_set);
  SWIG_addvarlink(globals, "InstrAttribType_COUPON_PERIOD", Swig_var_InstrAttribType_COUPON_PERIOD_get, Swig_var_InstrAttribType_COUPON_PERIOD_set);
  SWIG_addvarlink(globals, "InstrAttribType_WHEN", Swig_var_InstrAttribType_WHEN_get, Swig_var_InstrAttribType_WHEN_set);
  SWIG_addvarlink(globals, "InstrAttribType_ORIGINAL_ISSUE_DISCOUNT", Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_get, Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_set);
  SWIG_addvarlink(globals, "InstrAttribType_CALLABLE", Swig_var_InstrAttribType_CALLABLE_get, Swig_var_InstrAttribType_CALLABLE_set);
  SWIG_addvarlink(globals, "InstrAttribType_ESCROWED_TO_MATURITY", Swig_var_InstrAttribType_ESCROWED_TO_MATURITY_get, Swig_var_InstrAttribType_ESCROWED_TO_MATURITY_set);
  SWIG_addvarlink(globals, "InstrAttribType_ESCROWED_TO_REDEMPTION_DATE", Swig_var_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_get, Swig_var_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_set);
  SWIG_addvarlink(globals, "InstrAttribType_PRE_REFUNDED", Swig_var_InstrAttribType_PRE_REFUNDED_get, Swig_var_InstrAttribType_PRE_REFUNDED_set);
  SWIG_addvarlink(globals, "InstrAttribType_IN_DEFAULT", Swig_var_InstrAttribType_IN_DEFAULT_get, Swig_var_InstrAttribType_IN_DEFAULT_set);
  SWIG_addvarlink(globals, "InstrAttribType_UNRATED", Swig_var_InstrAttribType_UNRATED_get, Swig_var_InstrAttribType_UNRATED_set);
  SWIG_addvarlink(globals, "InstrAttribType_TAXABLE", Swig_var_InstrAttribType_TAXABLE_get, Swig_var_InstrAttribType_TAXABLE_set);
  SWIG_addvarlink(globals, "InstrAttribType_INDEXED", Swig_var_InstrAttribType_INDEXED_get, Swig_var_InstrAttribType_INDEXED_set);
  SWIG_addvarlink(globals, "InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX", Swig_var_InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX_get, Swig_var_InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX_set);
  SWIG_addvarlink(globals, "InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE", Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_get, Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_set);
  SWIG_addvarlink(globals, "InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE", Swig_var_InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE_get, Swig_var_InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE_set);
  SWIG_addvarlink(globals, "InstrAttribType_CALLABLE_WITHOUT_NOTICE", Swig_var_InstrAttribType_CALLABLE_WITHOUT_NOTICE_get, Swig_var_InstrAttribType_CALLABLE_WITHOUT_NOTICE_set);
  SWIG_addvarlink(globals, "InstrAttribType_TEXT", Swig_var_InstrAttribType_TEXT_get, Swig_var_InstrAttribType_TEXT_set);
  SWIG_addvarlink(globals, "InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY", Swig_var_InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY_get, Swig_var_InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY_set);
  SWIG_addvarlink(globals, "InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY", Swig_var_InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY_get, Swig_var_InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY_set);
  SWIG_addvarlink(globals, "InstrAttribType_INSTRUMENT_DENOMINATOR", Swig_var_InstrAttribType_INSTRUMENT_DENOMINATOR_get, Swig_var_InstrAttribType_INSTRUMENT_DENOMINATOR_set);
  SWIG_addvarlink(globals, "InstrAttribType_INSTRUMENT_NUMERATOR", Swig_var_InstrAttribType_INSTRUMENT_NUMERATOR_get, Swig_var_InstrAttribType_INSTRUMENT_NUMERATOR_set);
  SWIG_addvarlink(globals, "InstrAttribType_INSTRUMENT_PRICE_PRECISION", Swig_var_InstrAttribType_INSTRUMENT_PRICE_PRECISION_get, Swig_var_InstrAttribType_INSTRUMENT_PRICE_PRECISION_set);
  SWIG_addvarlink(globals, "InstrAttribType_INSTRUMENT_STRIKE_PRICE", Swig_var_InstrAttribType_INSTRUMENT_STRIKE_PRICE_get, Swig_var_InstrAttribType_INSTRUMENT_STRIKE_PRICE_set);
  SWIG_addvarlink(globals, "InstrAttribType_TRADEABLE_INDICATOR", Swig_var_InstrAttribType_TRADEABLE_INDICATOR_get, Swig_var_InstrAttribType_TRADEABLE_INDICATOR_set);
  SWIG_addvarlink(globals, "InstrAttribType_INSTRUMENT_ELIGIBLE_ANON_ORDERS", Swig_var_InstrAttribType_INSTRUMENT_ELIGIBLE_ANON_ORDERS_get, Swig_var_InstrAttribType_INSTRUMENT_ELIGIBLE_ANON_ORDERS_set);
  SWIG_addvarlink(globals, "InstrAttribType_MIN_GUARANTEED_FILL_VOLUME", Swig_var_InstrAttribType_MIN_GUARANTEED_FILL_VOLUME_get, Swig_var_InstrAttribType_MIN_GUARANTEED_FILL_VOLUME_set);
  SWIG_addvarlink(globals, "InstrAttribType_MIN_GUARANTEED_FILL_STATUS", Swig_var_InstrAttribType_MIN_GUARANTEED_FILL_STATUS_get, Swig_var_InstrAttribType_MIN_GUARANTEED_FILL_STATUS_set);
  SWIG_addvarlink(globals, "InstrAttribType_TRADE_AT_SETTLEMENT_ELIGIBILITY", Swig_var_InstrAttribType_TRADE_AT_SETTLEMENT_ELIGIBILITY_get, Swig_var_InstrAttribType_TRADE_AT_SETTLEMENT_ELIGIBILITY_set);
  SWIG_addvarlink(globals, "InstrAttribType_TEST_INSTRUMENT", Swig_var_InstrAttribType_TEST_INSTRUMENT_get, Swig_var_InstrAttribType_TEST_INSTRUMENT_set);
  SWIG_addvarlink(globals, "InstrAttribType_DUMMY_INSTRUMENT", Swig_var_InstrAttribType_DUMMY_INSTRUMENT_get, Swig_var_InstrAttribType_DUMMY_INSTRUMENT_set);
  SWIG_addvarlink(globals, "InstrAttribType_NEGATIVE_SETTLEMENT_PRICE_ELIGIBILITY", Swig_var_InstrAttribType_NEGATIVE_SETTLEMENT_PRICE_ELIGIBILITY_get, Swig_var_InstrAttribType_NEGATIVE_SETTLEMENT_PRICE_ELIGIBILITY_set);
  SWIG_addvarlink(globals, "InstrAttribType_NEGATIVE_STRIKE_PRICE_ELIGIBILITY", Swig_var_InstrAttribType_NEGATIVE_STRIKE_PRICE_ELIGIBILITY_get, Swig_var_InstrAttribType_NEGATIVE_STRIKE_PRICE_ELIGIBILITY_set);
  SWIG_addvarlink(globals, "InstrAttribType_US_STD_CONTRACT_IND", Swig_var_InstrAttribType_US_STD_CONTRACT_IND_get, Swig_var_InstrAttribType_US_STD_CONTRACT_IND_set);
  SWIG_addvarlink(globals, "InstrAttribType_ADMITTED_TO_TRADING_ON_TRADING_VENUE", Swig_var_InstrAttribType_ADMITTED_TO_TRADING_ON_TRADING_VENUE_get, Swig_var_InstrAttribType_ADMITTED_TO_TRADING_ON_TRADING_VENUE_set);
  SWIG_addvarlink(globals, "InstrAttribType_AVERAGE_DAILY_NOTIONAL_AMOUNT", Swig_var_InstrAttribType_AVERAGE_DAILY_NOTIONAL_AMOUNT_get, Swig_var_InstrAttribType_AVERAGE_DAILY_NOTIONAL_AMOUNT_set);
  SWIG_addvarlink(globals, "InstrAttribType_AVERAGE_DAILY_NUMBER_TRADES", Swig_var_InstrAttribType_AVERAGE_DAILY_NUMBER_TRADES_get, Swig_var_InstrAttribType_AVERAGE_DAILY_NUMBER_TRADES_set);
  SWIG_addvarlink(globals, "CPProgram_PROGRAM3A3", Swig_var_CPProgram_PROGRAM3A3_get, Swig_var_CPProgram_PROGRAM3A3_set);
  SWIG_addvarlink(globals, "CPProgram_PROGRAM42", Swig_var_CPProgram_PROGRAM42_get, Swig_var_CPProgram_PROGRAM42_set);
  SWIG_addvarlink(globals, "CPProgram_OTHER", Swig_var_CPProgram_OTHER_get, Swig_var_CPProgram_OTHER_set);
  SWIG_addvarlink(globals, "CPProgram_PROGRAM3A2", Swig_var_CPProgram_PROGRAM3A2_get, Swig_var_CPProgram_PROGRAM3A2_set);
  SWIG_addvarlink(globals, "CPProgram_PROGRAM3A3_AND3C7", Swig_var_CPProgram_PROGRAM3A3_AND3C7_get, Swig_var_CPProgram_PROGRAM3A3_AND3C7_set);
  SWIG_addvarlink(globals, "CPProgram_PROGRAM3A4", Swig_var_CPProgram_PROGRAM3A4_get, Swig_var_CPProgram_PROGRAM3A4_set);
  SWIG_addvarlink(globals, "CPProgram_PROGRAM3A5", Swig_var_CPProgram_PROGRAM3A5_get, Swig_var_CPProgram_PROGRAM3A5_set);
  SWIG_addvarlink(globals, "CPProgram_PROGRAM3A7", Swig_var_CPProgram_PROGRAM3A7_get, Swig_var_CPProgram_PROGRAM3A7_set);
  SWIG_addvarlink(globals, "CPProgram_PROGRAM3C7", Swig_var_CPProgram_PROGRAM3C7_get, Swig_var_CPProgram_PROGRAM3C7_set);
  SWIG_addvarlink(globals, "MiscFeeBasis_ABSOLUTE", Swig_var_MiscFeeBasis_ABSOLUTE_get, Swig_var_MiscFeeBasis_ABSOLUTE_set);
  SWIG_addvarlink(globals, "MiscFeeBasis_PER_UNIT", Swig_var_MiscFeeBasis_PER_UNIT_get, Swig_var_MiscFeeBasis_PER_UNIT_set);
  SWIG_addvarlink(globals, "MiscFeeBasis_PERCENTAGE", Swig_var_MiscFeeBasis_PERCENTAGE_get, Swig_var_MiscFeeBasis_PERCENTAGE_set);
  SWIG_addvarlink(globals, "LastFragment_YES", Swig_var_LastFragment_YES_get, Swig_var_LastFragment_YES_set);
  SWIG_addvarlink(globals, "LastFragment_NO", Swig_var_LastFragment_NO_get, Swig_var_LastFragment_NO_set);
  SWIG_addvarlink(globals, "CollAsgnReason_INITIAL", Swig_var_CollAsgnReason_INITIAL_get, Swig_var_CollAsgnReason_INITIAL_set);
  SWIG_addvarlink(globals, "CollAsgnReason_SCHEDULED", Swig_var_CollAsgnReason_SCHEDULED_get, Swig_var_CollAsgnReason_SCHEDULED_set);
  SWIG_addvarlink(globals, "CollAsgnReason_TIME_WARNING", Swig_var_CollAsgnReason_TIME_WARNING_get, Swig_var_CollAsgnReason_TIME_WARNING_set);
  SWIG_addvarlink(globals, "CollAsgnReason_MARGIN_DEFICIENCY", Swig_var_CollAsgnReason_MARGIN_DEFICIENCY_get, Swig_var_CollAsgnReason_MARGIN_DEFICIENCY_set);
  SWIG_addvarlink(globals, "CollAsgnReason_MARGIN_EXCESS", Swig_var_CollAsgnReason_MARGIN_EXCESS_get, Swig_var_CollAsgnReason_MARGIN_EXCESS_set);
  SWIG_addvarlink(globals, "CollAsgnReason_FORWARD_COLLATERAL_DEMAND", Swig_var_CollAsgnReason_FORWARD_COLLATERAL_DEMAND_get, Swig_var_CollAsgnReason_FORWARD_COLLATERAL_DEMAND_set);
  SWIG_addvarlink(globals, "CollAsgnReason_EVENT_OF_DEFAULT", Swig_var_CollAsgnReason_EVENT_OF_DEFAULT_get, Swig_var_CollAsgnReason_EVENT_OF_DEFAULT_set);
  SWIG_addvarlink(globals, "CollAsgnReason_ADVERSE_TAX_EVENT", Swig_var_CollAsgnReason_ADVERSE_TAX_EVENT_get, Swig_var_CollAsgnReason_ADVERSE_TAX_EVENT_set);
  SWIG_addvarlink(globals, "CollAsgnReason_TRANSFER_DEPOSIT", Swig_var_CollAsgnReason_TRANSFER_DEPOSIT_get, Swig_var_CollAsgnReason_TRANSFER_DEPOSIT_set);
  SWIG_addvarlink(globals, "CollAsgnReason_TRANSFER_WITHDRAWAL", Swig_var_CollAsgnReason_TRANSFER_WITHDRAWAL_get, Swig_var_CollAsgnReason_TRANSFER_WITHDRAWAL_set);
  SWIG_addvarlink(globals, "CollAsgnReason_PLEDGE", Swig_var_CollAsgnReason_PLEDGE_get, Swig_var_CollAsgnReason_PLEDGE_set);
  SWIG_addvarlink(globals, "CollInquiryQualifier_TRADE_DATE", Swig_var_CollInquiryQualifier_TRADE_DATE_get, Swig_var_CollInquiryQualifier_TRADE_DATE_set);
  SWIG_addvarlink(globals, "CollInquiryQualifier_GC_INSTRUMENT", Swig_var_CollInquiryQualifier_GC_INSTRUMENT_get, Swig_var_CollInquiryQualifier_GC_INSTRUMENT_set);
  SWIG_addvarlink(globals, "CollInquiryQualifier_COLLATERAL_INSTRUMENT", Swig_var_CollInquiryQualifier_COLLATERAL_INSTRUMENT_get, Swig_var_CollInquiryQualifier_COLLATERAL_INSTRUMENT_set);
  SWIG_addvarlink(globals, "CollInquiryQualifier_SUBSTITUTION_ELIGIBLE", Swig_var_CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_get, Swig_var_CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_set);
  SWIG_addvarlink(globals, "CollInquiryQualifier_NOT_ASSIGNED", Swig_var_CollInquiryQualifier_NOT_ASSIGNED_get, Swig_var_CollInquiryQualifier_NOT_ASSIGNED_set);
  SWIG_addvarlink(globals, "CollInquiryQualifier_PARTIALLY_ASSIGNED", Swig_var_CollInquiryQualifier_PARTIALLY_ASSIGNED_get, Swig_var_CollInquiryQualifier_PARTIALLY_ASSIGNED_set);
  SWIG_addvarlink(globals, "CollInquiryQualifier_FULLY_ASSIGNED", Swig_var_CollInquiryQualifier_FULLY_ASSIGNED_get, Swig_var_CollInquiryQualifier_FULLY_ASSIGNED_set);
  SWIG_addvarlink(globals, "CollInquiryQualifier_OUTSTANDING_TRADES", Swig_var_CollInquiryQualifier_OUTSTANDING_TRADES_get, Swig_var_CollInquiryQualifier_OUTSTANDING_TRADES_set);
  SWIG_addvarlink(globals, "CollAsgnTransType_NEW", Swig_var_CollAsgnTransType_NEW_get, Swig_var_CollAsgnTransType_NEW_set);
  SWIG_addvarlink(globals, "CollAsgnTransType_REPLACE", Swig_var_CollAsgnTransType_REPLACE_get, Swig_var_CollAsgnTransType_REPLACE_set);
  SWIG_addvarlink(globals, "CollAsgnTransType_CANCEL", Swig_var_CollAsgnTransType_CANCEL_get, Swig_var_CollAsgnTransType_CANCEL_set);
  SWIG_addvarlink(globals, "CollAsgnTransType_RELEASE", Swig_var_CollAsgnTransType_RELEASE_get, Swig_var_CollAsgnTransType_RELEASE_set);
  SWIG_addvarlink(globals, "CollAsgnTransType_REVERSE", Swig_var_CollAsgnTransType_REVERSE_get, Swig_var_CollAsgnTransType_REVERSE_set);
  SWIG_addvarlink(globals, "CollAsgnRespType_RECEIVED", Swig_var_CollAsgnRespType_RECEIVED_get, Swig_var_CollAsgnRespType_RECEIVED_set);
  SWIG_addvarlink(globals, "CollAsgnRespType_ACCEPTED", Swig_var_CollAsgnRespType_ACCEPTED_get, Swig_var_CollAsgnRespType_ACCEPTED_set);
  SWIG_addvarlink(globals, "CollAsgnRespType_DECLINED", Swig_var_CollAsgnRespType_DECLINED_get, Swig_var_CollAsgnRespType_DECLINED_set);
  SWIG_addvarlink(globals, "CollAsgnRespType_REJECTED", Swig_var_CollAsgnRespType_REJECTED_get, Swig_var_CollAsgnRespType_REJECTED_set);
  SWIG_addvarlink(globals, "CollAsgnRespType_TRANSACTION_PENDING", Swig_var_CollAsgnRespType_TRANSACTION_PENDING_get, Swig_var_CollAsgnRespType_TRANSACTION_PENDING_set);
  SWIG_addvarlink(globals, "CollAsgnRespType_TRANSACTION_COMPLETED_WITH_WARNING", Swig_var_CollAsgnRespType_TRANSACTION_COMPLETED_WITH_WARNING_get, Swig_var_CollAsgnRespType_TRANSACTION_COMPLETED_WITH_WARNING_set);
  SWIG_addvarlink(globals, "CollAsgnRejectReason_UNKNOWN_DEAL", Swig_var_CollAsgnRejectReason_UNKNOWN_DEAL_get, Swig_var_CollAsgnRejectReason_UNKNOWN_DEAL_set);
  SWIG_addvarlink(globals, "CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT", Swig_var_CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT_get, Swig_var_CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT_set);
  SWIG_addvarlink(globals, "CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION", Swig_var_CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_get, Swig_var_CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_set);
  SWIG_addvarlink(globals, "CollAsgnRejectReason_INSUFFICIENT_COLLATERAL", Swig_var_CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_get, Swig_var_CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_set);
  SWIG_addvarlink(globals, "CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL", Swig_var_CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL_get, Swig_var_CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL_set);
  SWIG_addvarlink(globals, "CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION", Swig_var_CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_get, Swig_var_CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_set);
  SWIG_addvarlink(globals, "CollAsgnRejectReason_OTHER", Swig_var_CollAsgnRejectReason_OTHER_get, Swig_var_CollAsgnRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "CollStatus_UNASSIGNED", Swig_var_CollStatus_UNASSIGNED_get, Swig_var_CollStatus_UNASSIGNED_set);
  SWIG_addvarlink(globals, "CollStatus_PARTIALLY_ASSIGNED", Swig_var_CollStatus_PARTIALLY_ASSIGNED_get, Swig_var_CollStatus_PARTIALLY_ASSIGNED_set);
  SWIG_addvarlink(globals, "CollStatus_ASSIGNMENT_PROPOSED", Swig_var_CollStatus_ASSIGNMENT_PROPOSED_get, Swig_var_CollStatus_ASSIGNMENT_PROPOSED_set);
  SWIG_addvarlink(globals, "CollStatus_ASSIGNED", Swig_var_CollStatus_ASSIGNED_get, Swig_var_CollStatus_ASSIGNED_set);
  SWIG_addvarlink(globals, "CollStatus_CHALLENGED", Swig_var_CollStatus_CHALLENGED_get, Swig_var_CollStatus_CHALLENGED_set);
  SWIG_addvarlink(globals, "CollStatus_REUSED", Swig_var_CollStatus_REUSED_get, Swig_var_CollStatus_REUSED_set);
  SWIG_addvarlink(globals, "LastRptRequested_NO", Swig_var_LastRptRequested_NO_get, Swig_var_LastRptRequested_NO_set);
  SWIG_addvarlink(globals, "LastRptRequested_YES", Swig_var_LastRptRequested_YES_get, Swig_var_LastRptRequested_YES_set);
  SWIG_addvarlink(globals, "DeliveryType_VERSUS_PAYMENT", Swig_var_DeliveryType_VERSUS_PAYMENT_get, Swig_var_DeliveryType_VERSUS_PAYMENT_set);
  SWIG_addvarlink(globals, "DeliveryType_FREE", Swig_var_DeliveryType_FREE_get, Swig_var_DeliveryType_FREE_set);
  SWIG_addvarlink(globals, "DeliveryType_TRI_PARTY", Swig_var_DeliveryType_TRI_PARTY_get, Swig_var_DeliveryType_TRI_PARTY_set);
  SWIG_addvarlink(globals, "DeliveryType_HOLD_IN_CUSTODY", Swig_var_DeliveryType_HOLD_IN_CUSTODY_get, Swig_var_DeliveryType_HOLD_IN_CUSTODY_set);
  SWIG_addvarlink(globals, "DeliveryType_DELIVER_BY_VALUE", Swig_var_DeliveryType_DELIVER_BY_VALUE_get, Swig_var_DeliveryType_DELIVER_BY_VALUE_set);
  SWIG_addvarlink(globals, "UserRequestType_LOG_ON_USER", Swig_var_UserRequestType_LOG_ON_USER_get, Swig_var_UserRequestType_LOG_ON_USER_set);
  SWIG_addvarlink(globals, "UserRequestType_LOG_OFF_USER", Swig_var_UserRequestType_LOG_OFF_USER_get, Swig_var_UserRequestType_LOG_OFF_USER_set);
  SWIG_addvarlink(globals, "UserRequestType_CHANGE_PASSWORD_FOR_USER", Swig_var_UserRequestType_CHANGE_PASSWORD_FOR_USER_get, Swig_var_UserRequestType_CHANGE_PASSWORD_FOR_USER_set);
  SWIG_addvarlink(globals, "UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS", Swig_var_UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS_get, Swig_var_UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS_set);
  SWIG_addvarlink(globals, "UserRequestType_REQUEST_THROTTLE_LIMIT", Swig_var_UserRequestType_REQUEST_THROTTLE_LIMIT_get, Swig_var_UserRequestType_REQUEST_THROTTLE_LIMIT_set);
  SWIG_addvarlink(globals, "UserStatus_LOGGED_IN", Swig_var_UserStatus_LOGGED_IN_get, Swig_var_UserStatus_LOGGED_IN_set);
  SWIG_addvarlink(globals, "UserStatus_NOT_LOGGED_IN", Swig_var_UserStatus_NOT_LOGGED_IN_get, Swig_var_UserStatus_NOT_LOGGED_IN_set);
  SWIG_addvarlink(globals, "UserStatus_USER_NOT_RECOGNISED", Swig_var_UserStatus_USER_NOT_RECOGNISED_get, Swig_var_UserStatus_USER_NOT_RECOGNISED_set);
  SWIG_addvarlink(globals, "UserStatus_PASSWORD_INCORRECT", Swig_var_UserStatus_PASSWORD_INCORRECT_get, Swig_var_UserStatus_PASSWORD_INCORRECT_set);
  SWIG_addvarlink(globals, "UserStatus_PASSWORD_CHANGED", Swig_var_UserStatus_PASSWORD_CHANGED_get, Swig_var_UserStatus_PASSWORD_CHANGED_set);
  SWIG_addvarlink(globals, "UserStatus_OTHER", Swig_var_UserStatus_OTHER_get, Swig_var_UserStatus_OTHER_set);
  SWIG_addvarlink(globals, "UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE", Swig_var_UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE_get, Swig_var_UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE_set);
  SWIG_addvarlink(globals, "UserStatus_SESSION_SHUTDOWN_WARNING", Swig_var_UserStatus_SESSION_SHUTDOWN_WARNING_get, Swig_var_UserStatus_SESSION_SHUTDOWN_WARNING_set);
  SWIG_addvarlink(globals, "UserStatus_THROTTLE_PARAMETERS_CHANGED", Swig_var_UserStatus_THROTTLE_PARAMETERS_CHANGED_get, Swig_var_UserStatus_THROTTLE_PARAMETERS_CHANGED_set);
  SWIG_addvarlink(globals, "StatusValue_CONNECTED", Swig_var_StatusValue_CONNECTED_get, Swig_var_StatusValue_CONNECTED_set);
  SWIG_addvarlink(globals, "StatusValue_NOT_CONNECTED_UNEXPECTED", Swig_var_StatusValue_NOT_CONNECTED_UNEXPECTED_get, Swig_var_StatusValue_NOT_CONNECTED_UNEXPECTED_set);
  SWIG_addvarlink(globals, "StatusValue_NOT_CONNECTED_EXPECTED", Swig_var_StatusValue_NOT_CONNECTED_EXPECTED_get, Swig_var_StatusValue_NOT_CONNECTED_EXPECTED_set);
  SWIG_addvarlink(globals, "StatusValue_IN_PROCESS", Swig_var_StatusValue_IN_PROCESS_get, Swig_var_StatusValue_IN_PROCESS_set);
  SWIG_addvarlink(globals, "NetworkRequestType_SNAPSHOT", Swig_var_NetworkRequestType_SNAPSHOT_get, Swig_var_NetworkRequestType_SNAPSHOT_set);
  SWIG_addvarlink(globals, "NetworkRequestType_SUBSCRIBE", Swig_var_NetworkRequestType_SUBSCRIBE_get, Swig_var_NetworkRequestType_SUBSCRIBE_set);
  SWIG_addvarlink(globals, "NetworkRequestType_STOP_SUBSCRIBING", Swig_var_NetworkRequestType_STOP_SUBSCRIBING_get, Swig_var_NetworkRequestType_STOP_SUBSCRIBING_set);
  SWIG_addvarlink(globals, "NetworkRequestType_LEVEL_OF_DETAIL", Swig_var_NetworkRequestType_LEVEL_OF_DETAIL_get, Swig_var_NetworkRequestType_LEVEL_OF_DETAIL_set);
  SWIG_addvarlink(globals, "NetworkStatusResponseType_FULL", Swig_var_NetworkStatusResponseType_FULL_get, Swig_var_NetworkStatusResponseType_FULL_set);
  SWIG_addvarlink(globals, "NetworkStatusResponseType_INCREMENTAL_UPDATE", Swig_var_NetworkStatusResponseType_INCREMENTAL_UPDATE_get, Swig_var_NetworkStatusResponseType_INCREMENTAL_UPDATE_set);
  SWIG_addvarlink(globals, "TrdRptStatus_ACCEPTED", Swig_var_TrdRptStatus_ACCEPTED_get, Swig_var_TrdRptStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "TrdRptStatus_REJECTED", Swig_var_TrdRptStatus_REJECTED_get, Swig_var_TrdRptStatus_REJECTED_set);
  SWIG_addvarlink(globals, "TrdRptStatus_ACCEPTED_WITH_ERRORS", Swig_var_TrdRptStatus_ACCEPTED_WITH_ERRORS_get, Swig_var_TrdRptStatus_ACCEPTED_WITH_ERRORS_set);
  SWIG_addvarlink(globals, "TrdRptStatus_CANCELLED", Swig_var_TrdRptStatus_CANCELLED_get, Swig_var_TrdRptStatus_CANCELLED_set);
  SWIG_addvarlink(globals, "TrdRptStatus_PENDING_NEW", Swig_var_TrdRptStatus_PENDING_NEW_get, Swig_var_TrdRptStatus_PENDING_NEW_set);
  SWIG_addvarlink(globals, "TrdRptStatus_PENDING_CANCEL", Swig_var_TrdRptStatus_PENDING_CANCEL_get, Swig_var_TrdRptStatus_PENDING_CANCEL_set);
  SWIG_addvarlink(globals, "TrdRptStatus_PENDING_REPLACE", Swig_var_TrdRptStatus_PENDING_REPLACE_get, Swig_var_TrdRptStatus_PENDING_REPLACE_set);
  SWIG_addvarlink(globals, "TrdRptStatus_TERMINATED", Swig_var_TrdRptStatus_TERMINATED_get, Swig_var_TrdRptStatus_TERMINATED_set);
  SWIG_addvarlink(globals, "TrdRptStatus_PENDING_VERIFICATION", Swig_var_TrdRptStatus_PENDING_VERIFICATION_get, Swig_var_TrdRptStatus_PENDING_VERIFICATION_set);
  SWIG_addvarlink(globals, "TrdRptStatus_DEEMED_VERIFIED", Swig_var_TrdRptStatus_DEEMED_VERIFIED_get, Swig_var_TrdRptStatus_DEEMED_VERIFIED_set);
  SWIG_addvarlink(globals, "TrdRptStatus_VERIFIED", Swig_var_TrdRptStatus_VERIFIED_get, Swig_var_TrdRptStatus_VERIFIED_set);
  SWIG_addvarlink(globals, "TrdRptStatus_DISPUTED", Swig_var_TrdRptStatus_DISPUTED_get, Swig_var_TrdRptStatus_DISPUTED_set);
  SWIG_addvarlink(globals, "AffirmStatus_RECEIVED", Swig_var_AffirmStatus_RECEIVED_get, Swig_var_AffirmStatus_RECEIVED_set);
  SWIG_addvarlink(globals, "AffirmStatus_CONFIRM_REJECTED", Swig_var_AffirmStatus_CONFIRM_REJECTED_get, Swig_var_AffirmStatus_CONFIRM_REJECTED_set);
  SWIG_addvarlink(globals, "AffirmStatus_AFFIRMED", Swig_var_AffirmStatus_AFFIRMED_get, Swig_var_AffirmStatus_AFFIRMED_set);
  SWIG_addvarlink(globals, "CollAction_RETAIN", Swig_var_CollAction_RETAIN_get, Swig_var_CollAction_RETAIN_set);
  SWIG_addvarlink(globals, "CollAction_ADD", Swig_var_CollAction_ADD_get, Swig_var_CollAction_ADD_set);
  SWIG_addvarlink(globals, "CollAction_REMOVE", Swig_var_CollAction_REMOVE_get, Swig_var_CollAction_REMOVE_set);
  SWIG_addvarlink(globals, "CollInquiryStatus_ACCEPTED", Swig_var_CollInquiryStatus_ACCEPTED_get, Swig_var_CollInquiryStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "CollInquiryStatus_ACCEPTED_WITH_WARNINGS", Swig_var_CollInquiryStatus_ACCEPTED_WITH_WARNINGS_get, Swig_var_CollInquiryStatus_ACCEPTED_WITH_WARNINGS_set);
  SWIG_addvarlink(globals, "CollInquiryStatus_COMPLETED", Swig_var_CollInquiryStatus_COMPLETED_get, Swig_var_CollInquiryStatus_COMPLETED_set);
  SWIG_addvarlink(globals, "CollInquiryStatus_COMPLETED_WITH_WARNINGS", Swig_var_CollInquiryStatus_COMPLETED_WITH_WARNINGS_get, Swig_var_CollInquiryStatus_COMPLETED_WITH_WARNINGS_set);
  SWIG_addvarlink(globals, "CollInquiryStatus_REJECTED", Swig_var_CollInquiryStatus_REJECTED_get, Swig_var_CollInquiryStatus_REJECTED_set);
  SWIG_addvarlink(globals, "CollInquiryResult_SUCCESSFUL", Swig_var_CollInquiryResult_SUCCESSFUL_get, Swig_var_CollInquiryResult_SUCCESSFUL_set);
  SWIG_addvarlink(globals, "CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT", Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT_get, Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT_set);
  SWIG_addvarlink(globals, "CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE", Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE_get, Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE_set);
  SWIG_addvarlink(globals, "CollInquiryResult_INVALID_PARTIES", Swig_var_CollInquiryResult_INVALID_PARTIES_get, Swig_var_CollInquiryResult_INVALID_PARTIES_set);
  SWIG_addvarlink(globals, "CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED", Swig_var_CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED_get, Swig_var_CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED_set);
  SWIG_addvarlink(globals, "CollInquiryResult_INVALID_DESTINATION_REQUESTED", Swig_var_CollInquiryResult_INVALID_DESTINATION_REQUESTED_get, Swig_var_CollInquiryResult_INVALID_DESTINATION_REQUESTED_set);
  SWIG_addvarlink(globals, "CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED", Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED_get, Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED_set);
  SWIG_addvarlink(globals, "CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED", Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED_get, Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED_set);
  SWIG_addvarlink(globals, "CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED", Swig_var_CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED_get, Swig_var_CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY", Swig_var_CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY_get, Swig_var_CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY_set);
  SWIG_addvarlink(globals, "CollInquiryResult_OTHER", Swig_var_CollInquiryResult_OTHER_get, Swig_var_CollInquiryResult_OTHER_set);
  SWIG_addvarlink(globals, "StrategyParameterType_INT", Swig_var_StrategyParameterType_INT_get, Swig_var_StrategyParameterType_INT_set);
  SWIG_addvarlink(globals, "StrategyParameterType_LENGTH", Swig_var_StrategyParameterType_LENGTH_get, Swig_var_StrategyParameterType_LENGTH_set);
  SWIG_addvarlink(globals, "StrategyParameterType_NUM_IN_GROUP", Swig_var_StrategyParameterType_NUM_IN_GROUP_get, Swig_var_StrategyParameterType_NUM_IN_GROUP_set);
  SWIG_addvarlink(globals, "StrategyParameterType_SEQ_NUM", Swig_var_StrategyParameterType_SEQ_NUM_get, Swig_var_StrategyParameterType_SEQ_NUM_set);
  SWIG_addvarlink(globals, "StrategyParameterType_TAG_NUM", Swig_var_StrategyParameterType_TAG_NUM_get, Swig_var_StrategyParameterType_TAG_NUM_set);
  SWIG_addvarlink(globals, "StrategyParameterType_FLOAT", Swig_var_StrategyParameterType_FLOAT_get, Swig_var_StrategyParameterType_FLOAT_set);
  SWIG_addvarlink(globals, "StrategyParameterType_QTY", Swig_var_StrategyParameterType_QTY_get, Swig_var_StrategyParameterType_QTY_set);
  SWIG_addvarlink(globals, "StrategyParameterType_PRICE", Swig_var_StrategyParameterType_PRICE_get, Swig_var_StrategyParameterType_PRICE_set);
  SWIG_addvarlink(globals, "StrategyParameterType_PRICE_OFFSET", Swig_var_StrategyParameterType_PRICE_OFFSET_get, Swig_var_StrategyParameterType_PRICE_OFFSET_set);
  SWIG_addvarlink(globals, "StrategyParameterType_AMT", Swig_var_StrategyParameterType_AMT_get, Swig_var_StrategyParameterType_AMT_set);
  SWIG_addvarlink(globals, "StrategyParameterType_PERCENTAGE", Swig_var_StrategyParameterType_PERCENTAGE_get, Swig_var_StrategyParameterType_PERCENTAGE_set);
  SWIG_addvarlink(globals, "StrategyParameterType_CHAR", Swig_var_StrategyParameterType_CHAR_get, Swig_var_StrategyParameterType_CHAR_set);
  SWIG_addvarlink(globals, "StrategyParameterType_BOOLEAN", Swig_var_StrategyParameterType_BOOLEAN_get, Swig_var_StrategyParameterType_BOOLEAN_set);
  SWIG_addvarlink(globals, "StrategyParameterType_STRING", Swig_var_StrategyParameterType_STRING_get, Swig_var_StrategyParameterType_STRING_set);
  SWIG_addvarlink(globals, "StrategyParameterType_MULTIPLE_CHAR_VALUE", Swig_var_StrategyParameterType_MULTIPLE_CHAR_VALUE_get, Swig_var_StrategyParameterType_MULTIPLE_CHAR_VALUE_set);
  SWIG_addvarlink(globals, "StrategyParameterType_CURRENCY", Swig_var_StrategyParameterType_CURRENCY_get, Swig_var_StrategyParameterType_CURRENCY_set);
  SWIG_addvarlink(globals, "StrategyParameterType_EXCHANGE", Swig_var_StrategyParameterType_EXCHANGE_get, Swig_var_StrategyParameterType_EXCHANGE_set);
  SWIG_addvarlink(globals, "StrategyParameterType_MONTH_YEAR", Swig_var_StrategyParameterType_MONTH_YEAR_get, Swig_var_StrategyParameterType_MONTH_YEAR_set);
  SWIG_addvarlink(globals, "StrategyParameterType_UTC_TIMESTAMP", Swig_var_StrategyParameterType_UTC_TIMESTAMP_get, Swig_var_StrategyParameterType_UTC_TIMESTAMP_set);
  SWIG_addvarlink(globals, "StrategyParameterType_UTC_TIME_ONLY", Swig_var_StrategyParameterType_UTC_TIME_ONLY_get, Swig_var_StrategyParameterType_UTC_TIME_ONLY_set);
  SWIG_addvarlink(globals, "StrategyParameterType_LOCAL_MKT_DATE", Swig_var_StrategyParameterType_LOCAL_MKT_DATE_get, Swig_var_StrategyParameterType_LOCAL_MKT_DATE_set);
  SWIG_addvarlink(globals, "StrategyParameterType_UTC_DATE_ONLY", Swig_var_StrategyParameterType_UTC_DATE_ONLY_get, Swig_var_StrategyParameterType_UTC_DATE_ONLY_set);
  SWIG_addvarlink(globals, "StrategyParameterType_DATA", Swig_var_StrategyParameterType_DATA_get, Swig_var_StrategyParameterType_DATA_set);
  SWIG_addvarlink(globals, "StrategyParameterType_MULTIPLE_STRING_VALUE", Swig_var_StrategyParameterType_MULTIPLE_STRING_VALUE_get, Swig_var_StrategyParameterType_MULTIPLE_STRING_VALUE_set);
  SWIG_addvarlink(globals, "StrategyParameterType_COUNTRY", Swig_var_StrategyParameterType_COUNTRY_get, Swig_var_StrategyParameterType_COUNTRY_set);
  SWIG_addvarlink(globals, "StrategyParameterType_LANGUAGE", Swig_var_StrategyParameterType_LANGUAGE_get, Swig_var_StrategyParameterType_LANGUAGE_set);
  SWIG_addvarlink(globals, "StrategyParameterType_TZ_TIME_ONLY", Swig_var_StrategyParameterType_TZ_TIME_ONLY_get, Swig_var_StrategyParameterType_TZ_TIME_ONLY_set);
  SWIG_addvarlink(globals, "StrategyParameterType_TZ_TIMESTAMP", Swig_var_StrategyParameterType_TZ_TIMESTAMP_get, Swig_var_StrategyParameterType_TZ_TIMESTAMP_set);
  SWIG_addvarlink(globals, "StrategyParameterType_TENOR", Swig_var_StrategyParameterType_TENOR_get, Swig_var_StrategyParameterType_TENOR_set);
  SWIG_addvarlink(globals, "SecurityStatus_ACTIVE", Swig_var_SecurityStatus_ACTIVE_get, Swig_var_SecurityStatus_ACTIVE_set);
  SWIG_addvarlink(globals, "SecurityStatus_INACTIVE", Swig_var_SecurityStatus_INACTIVE_get, Swig_var_SecurityStatus_INACTIVE_set);
  SWIG_addvarlink(globals, "SecurityStatus_ACTIVE_CLOSING_ORDERS_ONLY", Swig_var_SecurityStatus_ACTIVE_CLOSING_ORDERS_ONLY_get, Swig_var_SecurityStatus_ACTIVE_CLOSING_ORDERS_ONLY_set);
  SWIG_addvarlink(globals, "SecurityStatus_EXPIRED", Swig_var_SecurityStatus_EXPIRED_get, Swig_var_SecurityStatus_EXPIRED_set);
  SWIG_addvarlink(globals, "SecurityStatus_DELISTED", Swig_var_SecurityStatus_DELISTED_get, Swig_var_SecurityStatus_DELISTED_set);
  SWIG_addvarlink(globals, "SecurityStatus_KNOCKED_OUT", Swig_var_SecurityStatus_KNOCKED_OUT_get, Swig_var_SecurityStatus_KNOCKED_OUT_set);
  SWIG_addvarlink(globals, "SecurityStatus_KNOCK_OUT_REVOKED", Swig_var_SecurityStatus_KNOCK_OUT_REVOKED_get, Swig_var_SecurityStatus_KNOCK_OUT_REVOKED_set);
  SWIG_addvarlink(globals, "SecurityStatus_PENDING_EXPIRY", Swig_var_SecurityStatus_PENDING_EXPIRY_get, Swig_var_SecurityStatus_PENDING_EXPIRY_set);
  SWIG_addvarlink(globals, "SecurityStatus_SUSPENDED", Swig_var_SecurityStatus_SUSPENDED_get, Swig_var_SecurityStatus_SUSPENDED_set);
  SWIG_addvarlink(globals, "SecurityStatus_PUBLISHED", Swig_var_SecurityStatus_PUBLISHED_get, Swig_var_SecurityStatus_PUBLISHED_set);
  SWIG_addvarlink(globals, "SecurityStatus_PENDING_DELETION", Swig_var_SecurityStatus_PENDING_DELETION_get, Swig_var_SecurityStatus_PENDING_DELETION_set);
  SWIG_addvarlink(globals, "UnderlyingCashType_FIXED", Swig_var_UnderlyingCashType_FIXED_get, Swig_var_UnderlyingCashType_FIXED_set);
  SWIG_addvarlink(globals, "UnderlyingCashType_DIFF", Swig_var_UnderlyingCashType_DIFF_get, Swig_var_UnderlyingCashType_DIFF_set);
  SWIG_addvarlink(globals, "UnderlyingSettlementType_T_PLUS1", Swig_var_UnderlyingSettlementType_T_PLUS1_get, Swig_var_UnderlyingSettlementType_T_PLUS1_set);
  SWIG_addvarlink(globals, "UnderlyingSettlementType_T_PLUS3", Swig_var_UnderlyingSettlementType_T_PLUS3_get, Swig_var_UnderlyingSettlementType_T_PLUS3_set);
  SWIG_addvarlink(globals, "UnderlyingSettlementType_T_PLUS4", Swig_var_UnderlyingSettlementType_T_PLUS4_get, Swig_var_UnderlyingSettlementType_T_PLUS4_set);
  SWIG_addvarlink(globals, "SecurityUpdateAction_ADD", Swig_var_SecurityUpdateAction_ADD_get, Swig_var_SecurityUpdateAction_ADD_set);
  SWIG_addvarlink(globals, "SecurityUpdateAction_DELETE", Swig_var_SecurityUpdateAction_DELETE_get, Swig_var_SecurityUpdateAction_DELETE_set);
  SWIG_addvarlink(globals, "SecurityUpdateAction_MODIFY", Swig_var_SecurityUpdateAction_MODIFY_get, Swig_var_SecurityUpdateAction_MODIFY_set);
  SWIG_addvarlink(globals, "ExpType_AUTO_EXERCISE", Swig_var_ExpType_AUTO_EXERCISE_get, Swig_var_ExpType_AUTO_EXERCISE_set);
  SWIG_addvarlink(globals, "ExpType_NON_AUTO_EXERCISE", Swig_var_ExpType_NON_AUTO_EXERCISE_get, Swig_var_ExpType_NON_AUTO_EXERCISE_set);
  SWIG_addvarlink(globals, "ExpType_FINAL_WILL_BE_EXERCISED", Swig_var_ExpType_FINAL_WILL_BE_EXERCISED_get, Swig_var_ExpType_FINAL_WILL_BE_EXERCISED_set);
  SWIG_addvarlink(globals, "ExpType_CONTRARY_INTENTION", Swig_var_ExpType_CONTRARY_INTENTION_get, Swig_var_ExpType_CONTRARY_INTENTION_set);
  SWIG_addvarlink(globals, "ExpType_DIFFERENCE", Swig_var_ExpType_DIFFERENCE_get, Swig_var_ExpType_DIFFERENCE_set);
  SWIG_addvarlink(globals, "IndividualAllocType_SUB_ALLOCATE", Swig_var_IndividualAllocType_SUB_ALLOCATE_get, Swig_var_IndividualAllocType_SUB_ALLOCATE_set);
  SWIG_addvarlink(globals, "IndividualAllocType_THIRD_PARTY_ALLOCATION", Swig_var_IndividualAllocType_THIRD_PARTY_ALLOCATION_get, Swig_var_IndividualAllocType_THIRD_PARTY_ALLOCATION_set);
  SWIG_addvarlink(globals, "UnitofMeasure_BARRELS", Swig_var_UnitofMeasure_BARRELS_get, Swig_var_UnitofMeasure_BARRELS_set);
  SWIG_addvarlink(globals, "UnitofMeasure_BILLION_CUBIC_FEET", Swig_var_UnitofMeasure_BILLION_CUBIC_FEET_get, Swig_var_UnitofMeasure_BILLION_CUBIC_FEET_set);
  SWIG_addvarlink(globals, "UnitofMeasure_BUSHELS", Swig_var_UnitofMeasure_BUSHELS_get, Swig_var_UnitofMeasure_BUSHELS_set);
  SWIG_addvarlink(globals, "UnitofMeasure_POUNDS", Swig_var_UnitofMeasure_POUNDS_get, Swig_var_UnitofMeasure_POUNDS_set);
  SWIG_addvarlink(globals, "UnitofMeasure_GALLONS", Swig_var_UnitofMeasure_GALLONS_get, Swig_var_UnitofMeasure_GALLONS_set);
  SWIG_addvarlink(globals, "UnitofMeasure_MILLION_BARRELS", Swig_var_UnitofMeasure_MILLION_BARRELS_get, Swig_var_UnitofMeasure_MILLION_BARRELS_set);
  SWIG_addvarlink(globals, "UnitofMeasure_ONE_MILLION_BTU", Swig_var_UnitofMeasure_ONE_MILLION_BTU_get, Swig_var_UnitofMeasure_ONE_MILLION_BTU_set);
  SWIG_addvarlink(globals, "UnitofMeasure_MEGAWATT_HOURS", Swig_var_UnitofMeasure_MEGAWATT_HOURS_get, Swig_var_UnitofMeasure_MEGAWATT_HOURS_set);
  SWIG_addvarlink(globals, "UnitofMeasure_TROY_OUNCES", Swig_var_UnitofMeasure_TROY_OUNCES_get, Swig_var_UnitofMeasure_TROY_OUNCES_set);
  SWIG_addvarlink(globals, "UnitofMeasure_METRIC_TONS", Swig_var_UnitofMeasure_METRIC_TONS_get, Swig_var_UnitofMeasure_METRIC_TONS_set);
  SWIG_addvarlink(globals, "UnitofMeasure_TONS", Swig_var_UnitofMeasure_TONS_get, Swig_var_UnitofMeasure_TONS_set);
  SWIG_addvarlink(globals, "UnitofMeasure_US_DOLLARS", Swig_var_UnitofMeasure_US_DOLLARS_get, Swig_var_UnitofMeasure_US_DOLLARS_set);
  SWIG_addvarlink(globals, "TimeUnit_HOUR", Swig_var_TimeUnit_HOUR_get, Swig_var_TimeUnit_HOUR_set);
  SWIG_addvarlink(globals, "TimeUnit_MINUTE", Swig_var_TimeUnit_MINUTE_get, Swig_var_TimeUnit_MINUTE_set);
  SWIG_addvarlink(globals, "TimeUnit_SECOND", Swig_var_TimeUnit_SECOND_get, Swig_var_TimeUnit_SECOND_set);
  SWIG_addvarlink(globals, "TimeUnit_DAY", Swig_var_TimeUnit_DAY_get, Swig_var_TimeUnit_DAY_set);
  SWIG_addvarlink(globals, "TimeUnit_WEEK", Swig_var_TimeUnit_WEEK_get, Swig_var_TimeUnit_WEEK_set);
  SWIG_addvarlink(globals, "TimeUnit_MONTH", Swig_var_TimeUnit_MONTH_get, Swig_var_TimeUnit_MONTH_set);
  SWIG_addvarlink(globals, "TimeUnit_YEAR", Swig_var_TimeUnit_YEAR_get, Swig_var_TimeUnit_YEAR_set);
  SWIG_addvarlink(globals, "TimeUnit_QUARTER", Swig_var_TimeUnit_QUARTER_get, Swig_var_TimeUnit_QUARTER_set);
  SWIG_addvarlink(globals, "AllocMethod_AUTOMATIC", Swig_var_AllocMethod_AUTOMATIC_get, Swig_var_AllocMethod_AUTOMATIC_set);
  SWIG_addvarlink(globals, "AllocMethod_GUARANTOR", Swig_var_AllocMethod_GUARANTOR_get, Swig_var_AllocMethod_GUARANTOR_set);
  SWIG_addvarlink(globals, "AllocMethod_MANUAL", Swig_var_AllocMethod_MANUAL_get, Swig_var_AllocMethod_MANUAL_set);
  SWIG_addvarlink(globals, "AllocMethod_BROKER_ASSIGNED", Swig_var_AllocMethod_BROKER_ASSIGNED_get, Swig_var_AllocMethod_BROKER_ASSIGNED_set);
  SWIG_addvarlink(globals, "AsOfIndicator_FALSE", Swig_var_AsOfIndicator_FALSE_get, Swig_var_AsOfIndicator_FALSE_set);
  SWIG_addvarlink(globals, "AsOfIndicator_TRUE", Swig_var_AsOfIndicator_TRUE_get, Swig_var_AsOfIndicator_TRUE_set);
  SWIG_addvarlink(globals, "MDBookType_TOP_OF_BOOK", Swig_var_MDBookType_TOP_OF_BOOK_get, Swig_var_MDBookType_TOP_OF_BOOK_set);
  SWIG_addvarlink(globals, "MDBookType_PRICE_DEPTH", Swig_var_MDBookType_PRICE_DEPTH_get, Swig_var_MDBookType_PRICE_DEPTH_set);
  SWIG_addvarlink(globals, "MDBookType_ORDER_DEPTH", Swig_var_MDBookType_ORDER_DEPTH_get, Swig_var_MDBookType_ORDER_DEPTH_set);
  SWIG_addvarlink(globals, "MDOriginType_BOOK", Swig_var_MDOriginType_BOOK_get, Swig_var_MDOriginType_BOOK_set);
  SWIG_addvarlink(globals, "MDOriginType_OFF_BOOK", Swig_var_MDOriginType_OFF_BOOK_get, Swig_var_MDOriginType_OFF_BOOK_set);
  SWIG_addvarlink(globals, "MDOriginType_CROSS", Swig_var_MDOriginType_CROSS_get, Swig_var_MDOriginType_CROSS_set);
  SWIG_addvarlink(globals, "MDOriginType_QUOTE_DRIVEN_MARKET", Swig_var_MDOriginType_QUOTE_DRIVEN_MARKET_get, Swig_var_MDOriginType_QUOTE_DRIVEN_MARKET_set);
  SWIG_addvarlink(globals, "MDOriginType_DARK_ORDER_BOOK", Swig_var_MDOriginType_DARK_ORDER_BOOK_get, Swig_var_MDOriginType_DARK_ORDER_BOOK_set);
  SWIG_addvarlink(globals, "MDOriginType_AUCTION_DRIVEN_MARKET", Swig_var_MDOriginType_AUCTION_DRIVEN_MARKET_get, Swig_var_MDOriginType_AUCTION_DRIVEN_MARKET_set);
  SWIG_addvarlink(globals, "MDOriginType_QUOTE_NEGOTIATION", Swig_var_MDOriginType_QUOTE_NEGOTIATION_get, Swig_var_MDOriginType_QUOTE_NEGOTIATION_set);
  SWIG_addvarlink(globals, "MDOriginType_VOICE_NEGOTIATION", Swig_var_MDOriginType_VOICE_NEGOTIATION_get, Swig_var_MDOriginType_VOICE_NEGOTIATION_set);
  SWIG_addvarlink(globals, "MDOriginType_HYBRID_MARKET", Swig_var_MDOriginType_HYBRID_MARKET_get, Swig_var_MDOriginType_HYBRID_MARKET_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_ADD_ON_ORDER", Swig_var_CustOrderHandlingInst_ADD_ON_ORDER_get, Swig_var_CustOrderHandlingInst_ADD_ON_ORDER_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_ALL_OR_NONE", Swig_var_CustOrderHandlingInst_ALL_OR_NONE_get, Swig_var_CustOrderHandlingInst_ALL_OR_NONE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_CASH_NOT_HELD", Swig_var_CustOrderHandlingInst_CASH_NOT_HELD_get, Swig_var_CustOrderHandlingInst_CASH_NOT_HELD_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_DIRECTED_ORDER", Swig_var_CustOrderHandlingInst_DIRECTED_ORDER_get, Swig_var_CustOrderHandlingInst_DIRECTED_ORDER_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION", Swig_var_CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get, Swig_var_CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_FILL_OR_KILL", Swig_var_CustOrderHandlingInst_FILL_OR_KILL_get, Swig_var_CustOrderHandlingInst_FILL_OR_KILL_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_IMBALANCE_ONLY", Swig_var_CustOrderHandlingInst_IMBALANCE_ONLY_get, Swig_var_CustOrderHandlingInst_IMBALANCE_ONLY_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_IMMEDIATE_OR_CANCEL", Swig_var_CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_get, Swig_var_CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_LIMIT_ON_OPEN", Swig_var_CustOrderHandlingInst_LIMIT_ON_OPEN_get, Swig_var_CustOrderHandlingInst_LIMIT_ON_OPEN_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_LIMIT_ON_CLOSE", Swig_var_CustOrderHandlingInst_LIMIT_ON_CLOSE_get, Swig_var_CustOrderHandlingInst_LIMIT_ON_CLOSE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_MARKET_AT_OPEN", Swig_var_CustOrderHandlingInst_MARKET_AT_OPEN_get, Swig_var_CustOrderHandlingInst_MARKET_AT_OPEN_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_MARKET_AT_CLOSE", Swig_var_CustOrderHandlingInst_MARKET_AT_CLOSE_get, Swig_var_CustOrderHandlingInst_MARKET_AT_CLOSE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_MARKET_ON_OPEN", Swig_var_CustOrderHandlingInst_MARKET_ON_OPEN_get, Swig_var_CustOrderHandlingInst_MARKET_ON_OPEN_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_MARKET_ON_CLOSE", Swig_var_CustOrderHandlingInst_MARKET_ON_CLOSE_get, Swig_var_CustOrderHandlingInst_MARKET_ON_CLOSE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_MINIMUM_QUANTITY", Swig_var_CustOrderHandlingInst_MINIMUM_QUANTITY_get, Swig_var_CustOrderHandlingInst_MINIMUM_QUANTITY_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_NOT_HELD", Swig_var_CustOrderHandlingInst_NOT_HELD_get, Swig_var_CustOrderHandlingInst_NOT_HELD_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_OVER_THE_DAY", Swig_var_CustOrderHandlingInst_OVER_THE_DAY_get, Swig_var_CustOrderHandlingInst_OVER_THE_DAY_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_PEGGED", Swig_var_CustOrderHandlingInst_PEGGED_get, Swig_var_CustOrderHandlingInst_PEGGED_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_RESERVE_SIZE_ORDER", Swig_var_CustOrderHandlingInst_RESERVE_SIZE_ORDER_get, Swig_var_CustOrderHandlingInst_RESERVE_SIZE_ORDER_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_STOP_STOCK_TRANSACTION", Swig_var_CustOrderHandlingInst_STOP_STOCK_TRANSACTION_get, Swig_var_CustOrderHandlingInst_STOP_STOCK_TRANSACTION_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_SCALE", Swig_var_CustOrderHandlingInst_SCALE_get, Swig_var_CustOrderHandlingInst_SCALE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_TIME_ORDER", Swig_var_CustOrderHandlingInst_TIME_ORDER_get, Swig_var_CustOrderHandlingInst_TIME_ORDER_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_TRAILING_STOP", Swig_var_CustOrderHandlingInst_TRAILING_STOP_get, Swig_var_CustOrderHandlingInst_TRAILING_STOP_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_WORK", Swig_var_CustOrderHandlingInst_WORK_get, Swig_var_CustOrderHandlingInst_WORK_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_PHONE_SIMPLE", Swig_var_CustOrderHandlingInst_PHONE_SIMPLE_get, Swig_var_CustOrderHandlingInst_PHONE_SIMPLE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_PHONE_COMPLEX", Swig_var_CustOrderHandlingInst_PHONE_COMPLEX_get, Swig_var_CustOrderHandlingInst_PHONE_COMPLEX_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_FCM_PROVIDED_SCREEN", Swig_var_CustOrderHandlingInst_FCM_PROVIDED_SCREEN_get, Swig_var_CustOrderHandlingInst_FCM_PROVIDED_SCREEN_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_OTHER_PROVIDED_SCREEN", Swig_var_CustOrderHandlingInst_OTHER_PROVIDED_SCREEN_get, Swig_var_CustOrderHandlingInst_OTHER_PROVIDED_SCREEN_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_CLIENT_PROVIDED_PLATFORM_CONTROLLED_BY_FCM", Swig_var_CustOrderHandlingInst_CLIENT_PROVIDED_PLATFORM_CONTROLLED_BY_FCM_get, Swig_var_CustOrderHandlingInst_CLIENT_PROVIDED_PLATFORM_CONTROLLED_BY_FCM_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_CLIENT_PROVIDED_PLATFORM_DIRECT_TO_EXCHANGE", Swig_var_CustOrderHandlingInst_CLIENT_PROVIDED_PLATFORM_DIRECT_TO_EXCHANGE_get, Swig_var_CustOrderHandlingInst_CLIENT_PROVIDED_PLATFORM_DIRECT_TO_EXCHANGE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_ALGO_ENGINE", Swig_var_CustOrderHandlingInst_ALGO_ENGINE_get, Swig_var_CustOrderHandlingInst_ALGO_ENGINE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_PRICE_AT_EXECUTION", Swig_var_CustOrderHandlingInst_PRICE_AT_EXECUTION_get, Swig_var_CustOrderHandlingInst_PRICE_AT_EXECUTION_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_DESK_ELECTRONIC", Swig_var_CustOrderHandlingInst_DESK_ELECTRONIC_get, Swig_var_CustOrderHandlingInst_DESK_ELECTRONIC_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_DESK_PIT", Swig_var_CustOrderHandlingInst_DESK_PIT_get, Swig_var_CustOrderHandlingInst_DESK_PIT_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_CLIENT_ELECTRONIC", Swig_var_CustOrderHandlingInst_CLIENT_ELECTRONIC_get, Swig_var_CustOrderHandlingInst_CLIENT_ELECTRONIC_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_CLIENT_PIT", Swig_var_CustOrderHandlingInst_CLIENT_PIT_get, Swig_var_CustOrderHandlingInst_CLIENT_PIT_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_CONDITIONAL_ORDER", Swig_var_CustOrderHandlingInst_CONDITIONAL_ORDER_get, Swig_var_CustOrderHandlingInst_CONDITIONAL_ORDER_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_CASH", Swig_var_CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_CASH_get, Swig_var_CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_CASH_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_DISCRETIONARY_LIMIT_ORDER", Swig_var_CustOrderHandlingInst_DISCRETIONARY_LIMIT_ORDER_get, Swig_var_CustOrderHandlingInst_DISCRETIONARY_LIMIT_ORDER_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_INTRA_DAY_CROSS", Swig_var_CustOrderHandlingInst_INTRA_DAY_CROSS_get, Swig_var_CustOrderHandlingInst_INTRA_DAY_CROSS_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_INTERMARKET_SWEEP_ORDER", Swig_var_CustOrderHandlingInst_INTERMARKET_SWEEP_ORDER_get, Swig_var_CustOrderHandlingInst_INTERMARKET_SWEEP_ORDER_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_MERGER_RELATED_TRANSFER_POSITION", Swig_var_CustOrderHandlingInst_MERGER_RELATED_TRANSFER_POSITION_get, Swig_var_CustOrderHandlingInst_MERGER_RELATED_TRANSFER_POSITION_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_MARKET_TO_LIMIT", Swig_var_CustOrderHandlingInst_MARKET_TO_LIMIT_get, Swig_var_CustOrderHandlingInst_MARKET_TO_LIMIT_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_NEXT_DAY", Swig_var_CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_NEXT_DAY_get, Swig_var_CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_NEXT_DAY_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_OPTIONS_RELATED_TRANSACTION", Swig_var_CustOrderHandlingInst_OPTIONS_RELATED_TRANSACTION_get, Swig_var_CustOrderHandlingInst_OPTIONS_RELATED_TRANSACTION_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_SELLERS_OPTION", Swig_var_CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_SELLERS_OPTION_get, Swig_var_CustOrderHandlingInst_DELIVERY_INSTRUCTIONS_SELLERS_OPTION_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_STAY_ON_OFFERSIDE", Swig_var_CustOrderHandlingInst_STAY_ON_OFFERSIDE_get, Swig_var_CustOrderHandlingInst_STAY_ON_OFFERSIDE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_GO_ALONG", Swig_var_CustOrderHandlingInst_GO_ALONG_get, Swig_var_CustOrderHandlingInst_GO_ALONG_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_PARTICIPATE_DO_NOT_INITIATE", Swig_var_CustOrderHandlingInst_PARTICIPATE_DO_NOT_INITIATE_get, Swig_var_CustOrderHandlingInst_PARTICIPATE_DO_NOT_INITIATE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_STRICT_SCALE", Swig_var_CustOrderHandlingInst_STRICT_SCALE_get, Swig_var_CustOrderHandlingInst_STRICT_SCALE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_TRY_TO_SCALE", Swig_var_CustOrderHandlingInst_TRY_TO_SCALE_get, Swig_var_CustOrderHandlingInst_TRY_TO_SCALE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_STAY_ON_BIDSIDE", Swig_var_CustOrderHandlingInst_STAY_ON_BIDSIDE_get, Swig_var_CustOrderHandlingInst_STAY_ON_BIDSIDE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_NO_CROSS", Swig_var_CustOrderHandlingInst_NO_CROSS_get, Swig_var_CustOrderHandlingInst_NO_CROSS_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_OK_TO_CROSS", Swig_var_CustOrderHandlingInst_OK_TO_CROSS_get, Swig_var_CustOrderHandlingInst_OK_TO_CROSS_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_CALL_FIRST", Swig_var_CustOrderHandlingInst_CALL_FIRST_get, Swig_var_CustOrderHandlingInst_CALL_FIRST_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_PERCENT_OF_VOLUME", Swig_var_CustOrderHandlingInst_PERCENT_OF_VOLUME_get, Swig_var_CustOrderHandlingInst_PERCENT_OF_VOLUME_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_REINSTATE_ON_SYSTEM_FAILURE", Swig_var_CustOrderHandlingInst_REINSTATE_ON_SYSTEM_FAILURE_get, Swig_var_CustOrderHandlingInst_REINSTATE_ON_SYSTEM_FAILURE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_INSTITUTION_ONLY", Swig_var_CustOrderHandlingInst_INSTITUTION_ONLY_get, Swig_var_CustOrderHandlingInst_INSTITUTION_ONLY_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_REINSTATE_ON_TRADING_HALT", Swig_var_CustOrderHandlingInst_REINSTATE_ON_TRADING_HALT_get, Swig_var_CustOrderHandlingInst_REINSTATE_ON_TRADING_HALT_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_CANCEL_ON_TRADING_HALF", Swig_var_CustOrderHandlingInst_CANCEL_ON_TRADING_HALF_get, Swig_var_CustOrderHandlingInst_CANCEL_ON_TRADING_HALF_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_LAST_PEG", Swig_var_CustOrderHandlingInst_LAST_PEG_get, Swig_var_CustOrderHandlingInst_LAST_PEG_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_MID_PRICE_PEG", Swig_var_CustOrderHandlingInst_MID_PRICE_PEG_get, Swig_var_CustOrderHandlingInst_MID_PRICE_PEG_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_NON_NEGOTIABLE", Swig_var_CustOrderHandlingInst_NON_NEGOTIABLE_get, Swig_var_CustOrderHandlingInst_NON_NEGOTIABLE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_OPENING_PEG", Swig_var_CustOrderHandlingInst_OPENING_PEG_get, Swig_var_CustOrderHandlingInst_OPENING_PEG_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_MARKET_PEG", Swig_var_CustOrderHandlingInst_MARKET_PEG_get, Swig_var_CustOrderHandlingInst_MARKET_PEG_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_CANCEL_ON_SYSTEM_FAILURE", Swig_var_CustOrderHandlingInst_CANCEL_ON_SYSTEM_FAILURE_get, Swig_var_CustOrderHandlingInst_CANCEL_ON_SYSTEM_FAILURE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_PRIMARY_PEG", Swig_var_CustOrderHandlingInst_PRIMARY_PEG_get, Swig_var_CustOrderHandlingInst_PRIMARY_PEG_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_SUSPEND", Swig_var_CustOrderHandlingInst_SUSPEND_get, Swig_var_CustOrderHandlingInst_SUSPEND_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_FIXED_PEG_TO_LOCAL_BBO", Swig_var_CustOrderHandlingInst_FIXED_PEG_TO_LOCAL_BBO_get, Swig_var_CustOrderHandlingInst_FIXED_PEG_TO_LOCAL_BBO_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_PEG_TO_VWAP", Swig_var_CustOrderHandlingInst_PEG_TO_VWAP_get, Swig_var_CustOrderHandlingInst_PEG_TO_VWAP_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_TRADE_ALONG", Swig_var_CustOrderHandlingInst_TRADE_ALONG_get, Swig_var_CustOrderHandlingInst_TRADE_ALONG_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_TRY_TO_STOP", Swig_var_CustOrderHandlingInst_TRY_TO_STOP_get, Swig_var_CustOrderHandlingInst_TRY_TO_STOP_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_CANCEL_IF_NOT_BEST", Swig_var_CustOrderHandlingInst_CANCEL_IF_NOT_BEST_get, Swig_var_CustOrderHandlingInst_CANCEL_IF_NOT_BEST_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_STRICT_LIMIT", Swig_var_CustOrderHandlingInst_STRICT_LIMIT_get, Swig_var_CustOrderHandlingInst_STRICT_LIMIT_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_IGNORE_PRICE_VALIDITY_CHECKS", Swig_var_CustOrderHandlingInst_IGNORE_PRICE_VALIDITY_CHECKS_get, Swig_var_CustOrderHandlingInst_IGNORE_PRICE_VALIDITY_CHECKS_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_PEG_TO_LIMIT_PRICE", Swig_var_CustOrderHandlingInst_PEG_TO_LIMIT_PRICE_get, Swig_var_CustOrderHandlingInst_PEG_TO_LIMIT_PRICE_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_WORK_TO_TARGET_STRATEGY", Swig_var_CustOrderHandlingInst_WORK_TO_TARGET_STRATEGY_get, Swig_var_CustOrderHandlingInst_WORK_TO_TARGET_STRATEGY_set);
  SWIG_addvarlink(globals, "CustOrderHandlingInst_G_ORDER_AND_FCMAP_IOR_FIX", Swig_var_CustOrderHandlingInst_G_ORDER_AND_FCMAP_IOR_FIX_get, Swig_var_CustOrderHandlingInst_G_ORDER_AND_FCMAP_IOR_FIX_set);
  SWIG_addvarlink(globals, "OrderHandlingInstSource_NASDOATS", Swig_var_OrderHandlingInstSource_NASDOATS_get, Swig_var_OrderHandlingInstSource_NASDOATS_set);
  SWIG_addvarlink(globals, "OrderHandlingInstSource_FINRAOATS", Swig_var_OrderHandlingInstSource_FINRAOATS_get, Swig_var_OrderHandlingInstSource_FINRAOATS_set);
  SWIG_addvarlink(globals, "OrderHandlingInstSource_FIA_EXECUTION_SOURCE_CODE", Swig_var_OrderHandlingInstSource_FIA_EXECUTION_SOURCE_CODE_get, Swig_var_OrderHandlingInstSource_FIA_EXECUTION_SOURCE_CODE_set);
  SWIG_addvarlink(globals, "DeskType_AGENCY", Swig_var_DeskType_AGENCY_get, Swig_var_DeskType_AGENCY_set);
  SWIG_addvarlink(globals, "DeskType_ARBITRAGE", Swig_var_DeskType_ARBITRAGE_get, Swig_var_DeskType_ARBITRAGE_set);
  SWIG_addvarlink(globals, "DeskType_DERIVATIVES", Swig_var_DeskType_DERIVATIVES_get, Swig_var_DeskType_DERIVATIVES_set);
  SWIG_addvarlink(globals, "DeskType_INTERNATIONAL", Swig_var_DeskType_INTERNATIONAL_get, Swig_var_DeskType_INTERNATIONAL_set);
  SWIG_addvarlink(globals, "DeskType_INSTITUTIONAL", Swig_var_DeskType_INSTITUTIONAL_get, Swig_var_DeskType_INSTITUTIONAL_set);
  SWIG_addvarlink(globals, "DeskType_OTHER", Swig_var_DeskType_OTHER_get, Swig_var_DeskType_OTHER_set);
  SWIG_addvarlink(globals, "DeskType_PREFERRED_TRADING", Swig_var_DeskType_PREFERRED_TRADING_get, Swig_var_DeskType_PREFERRED_TRADING_set);
  SWIG_addvarlink(globals, "DeskType_PROPRIETARY", Swig_var_DeskType_PROPRIETARY_get, Swig_var_DeskType_PROPRIETARY_set);
  SWIG_addvarlink(globals, "DeskType_PROGRAM_TRADING", Swig_var_DeskType_PROGRAM_TRADING_get, Swig_var_DeskType_PROGRAM_TRADING_set);
  SWIG_addvarlink(globals, "DeskType_SALES", Swig_var_DeskType_SALES_get, Swig_var_DeskType_SALES_set);
  SWIG_addvarlink(globals, "DeskType_TRADING", Swig_var_DeskType_TRADING_get, Swig_var_DeskType_TRADING_set);
  SWIG_addvarlink(globals, "DeskType_BLOCK_TRADING", Swig_var_DeskType_BLOCK_TRADING_get, Swig_var_DeskType_BLOCK_TRADING_set);
  SWIG_addvarlink(globals, "DeskType_CONVERTIBLE_DESK", Swig_var_DeskType_CONVERTIBLE_DESK_get, Swig_var_DeskType_CONVERTIBLE_DESK_set);
  SWIG_addvarlink(globals, "DeskType_CENTRAL_RISK_BOOKS", Swig_var_DeskType_CENTRAL_RISK_BOOKS_get, Swig_var_DeskType_CENTRAL_RISK_BOOKS_set);
  SWIG_addvarlink(globals, "DeskType_EQUITY_CAPITAL_MARKETS", Swig_var_DeskType_EQUITY_CAPITAL_MARKETS_get, Swig_var_DeskType_EQUITY_CAPITAL_MARKETS_set);
  SWIG_addvarlink(globals, "DeskType_SWAPS", Swig_var_DeskType_SWAPS_get, Swig_var_DeskType_SWAPS_set);
  SWIG_addvarlink(globals, "DeskType_TRADING_DESK_SYSTEM", Swig_var_DeskType_TRADING_DESK_SYSTEM_get, Swig_var_DeskType_TRADING_DESK_SYSTEM_set);
  SWIG_addvarlink(globals, "DeskType_TREASURY", Swig_var_DeskType_TREASURY_get, Swig_var_DeskType_TREASURY_set);
  SWIG_addvarlink(globals, "DeskType_FLOOR_BROKER", Swig_var_DeskType_FLOOR_BROKER_get, Swig_var_DeskType_FLOOR_BROKER_set);
  SWIG_addvarlink(globals, "DeskTypeSource_NASDOATS", Swig_var_DeskTypeSource_NASDOATS_get, Swig_var_DeskTypeSource_NASDOATS_set);
  SWIG_addvarlink(globals, "DeskTypeSource_FINRAOATS", Swig_var_DeskTypeSource_FINRAOATS_get, Swig_var_DeskTypeSource_FINRAOATS_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_ADD_ON_ORDER", Swig_var_DeskOrderHandlingInst_ADD_ON_ORDER_get, Swig_var_DeskOrderHandlingInst_ADD_ON_ORDER_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_ALL_OR_NONE", Swig_var_DeskOrderHandlingInst_ALL_OR_NONE_get, Swig_var_DeskOrderHandlingInst_ALL_OR_NONE_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_CASH_NOT_HELD", Swig_var_DeskOrderHandlingInst_CASH_NOT_HELD_get, Swig_var_DeskOrderHandlingInst_CASH_NOT_HELD_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_DIRECTED_ORDER", Swig_var_DeskOrderHandlingInst_DIRECTED_ORDER_get, Swig_var_DeskOrderHandlingInst_DIRECTED_ORDER_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION", Swig_var_DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get, Swig_var_DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_FILL_OR_KILL", Swig_var_DeskOrderHandlingInst_FILL_OR_KILL_get, Swig_var_DeskOrderHandlingInst_FILL_OR_KILL_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_IMBALANCE_ONLY", Swig_var_DeskOrderHandlingInst_IMBALANCE_ONLY_get, Swig_var_DeskOrderHandlingInst_IMBALANCE_ONLY_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL", Swig_var_DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_get, Swig_var_DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_LIMIT_ON_OPEN", Swig_var_DeskOrderHandlingInst_LIMIT_ON_OPEN_get, Swig_var_DeskOrderHandlingInst_LIMIT_ON_OPEN_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_LIMIT_ON_CLOSE", Swig_var_DeskOrderHandlingInst_LIMIT_ON_CLOSE_get, Swig_var_DeskOrderHandlingInst_LIMIT_ON_CLOSE_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_MARKET_AT_OPEN", Swig_var_DeskOrderHandlingInst_MARKET_AT_OPEN_get, Swig_var_DeskOrderHandlingInst_MARKET_AT_OPEN_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_MARKET_AT_CLOSE", Swig_var_DeskOrderHandlingInst_MARKET_AT_CLOSE_get, Swig_var_DeskOrderHandlingInst_MARKET_AT_CLOSE_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_MARKET_ON_OPEN", Swig_var_DeskOrderHandlingInst_MARKET_ON_OPEN_get, Swig_var_DeskOrderHandlingInst_MARKET_ON_OPEN_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_MARKET_ON_CLOSE", Swig_var_DeskOrderHandlingInst_MARKET_ON_CLOSE_get, Swig_var_DeskOrderHandlingInst_MARKET_ON_CLOSE_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_MINIMUM_QUANTITY", Swig_var_DeskOrderHandlingInst_MINIMUM_QUANTITY_get, Swig_var_DeskOrderHandlingInst_MINIMUM_QUANTITY_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_NOT_HELD", Swig_var_DeskOrderHandlingInst_NOT_HELD_get, Swig_var_DeskOrderHandlingInst_NOT_HELD_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_OVER_THE_DAY", Swig_var_DeskOrderHandlingInst_OVER_THE_DAY_get, Swig_var_DeskOrderHandlingInst_OVER_THE_DAY_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_PEGGED", Swig_var_DeskOrderHandlingInst_PEGGED_get, Swig_var_DeskOrderHandlingInst_PEGGED_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_RESERVE_SIZE_ORDER", Swig_var_DeskOrderHandlingInst_RESERVE_SIZE_ORDER_get, Swig_var_DeskOrderHandlingInst_RESERVE_SIZE_ORDER_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_STOP_STOCK_TRANSACTION", Swig_var_DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_get, Swig_var_DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_SCALE", Swig_var_DeskOrderHandlingInst_SCALE_get, Swig_var_DeskOrderHandlingInst_SCALE_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_TIME_ORDER", Swig_var_DeskOrderHandlingInst_TIME_ORDER_get, Swig_var_DeskOrderHandlingInst_TIME_ORDER_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_TRAILING_STOP", Swig_var_DeskOrderHandlingInst_TRAILING_STOP_get, Swig_var_DeskOrderHandlingInst_TRAILING_STOP_set);
  SWIG_addvarlink(globals, "DeskOrderHandlingInst_WORK", Swig_var_DeskOrderHandlingInst_WORK_get, Swig_var_DeskOrderHandlingInst_WORK_set);
  SWIG_addvarlink(globals, "ExecAckStatus_RECEIVED", Swig_var_ExecAckStatus_RECEIVED_get, Swig_var_ExecAckStatus_RECEIVED_set);
  SWIG_addvarlink(globals, "ExecAckStatus_ACCEPTED", Swig_var_ExecAckStatus_ACCEPTED_get, Swig_var_ExecAckStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "ExecAckStatus_DON", Swig_var_ExecAckStatus_DON_get, Swig_var_ExecAckStatus_DON_set);
  SWIG_addvarlink(globals, "ExecAckStatus_DONT_KNOW", Swig_var_ExecAckStatus_DONT_KNOW_get, Swig_var_ExecAckStatus_DONT_KNOW_set);
  SWIG_addvarlink(globals, "CollApplType_SPECIFIC_DEPOSIT", Swig_var_CollApplType_SPECIFIC_DEPOSIT_get, Swig_var_CollApplType_SPECIFIC_DEPOSIT_set);
  SWIG_addvarlink(globals, "CollApplType_GENERAL", Swig_var_CollApplType_GENERAL_get, Swig_var_CollApplType_GENERAL_set);
  SWIG_addvarlink(globals, "UnderlyingFXRateCalc_DIVIDE", Swig_var_UnderlyingFXRateCalc_DIVIDE_get, Swig_var_UnderlyingFXRateCalc_DIVIDE_set);
  SWIG_addvarlink(globals, "UnderlyingFXRateCalc_MULTIPLY", Swig_var_UnderlyingFXRateCalc_MULTIPLY_get, Swig_var_UnderlyingFXRateCalc_MULTIPLY_set);
  SWIG_addvarlink(globals, "AllocPositionEffect_OPEN", Swig_var_AllocPositionEffect_OPEN_get, Swig_var_AllocPositionEffect_OPEN_set);
  SWIG_addvarlink(globals, "AllocPositionEffect_CLOSE", Swig_var_AllocPositionEffect_CLOSE_get, Swig_var_AllocPositionEffect_CLOSE_set);
  SWIG_addvarlink(globals, "AllocPositionEffect_ROLLED", Swig_var_AllocPositionEffect_ROLLED_get, Swig_var_AllocPositionEffect_ROLLED_set);
  SWIG_addvarlink(globals, "AllocPositionEffect_FIFO", Swig_var_AllocPositionEffect_FIFO_get, Swig_var_AllocPositionEffect_FIFO_set);
  SWIG_addvarlink(globals, "DealingCapacity_AGENT", Swig_var_DealingCapacity_AGENT_get, Swig_var_DealingCapacity_AGENT_set);
  SWIG_addvarlink(globals, "DealingCapacity_PRINCIPAL", Swig_var_DealingCapacity_PRINCIPAL_get, Swig_var_DealingCapacity_PRINCIPAL_set);
  SWIG_addvarlink(globals, "DealingCapacity_RISKLESS_PRINCIPAL", Swig_var_DealingCapacity_RISKLESS_PRINCIPAL_get, Swig_var_DealingCapacity_RISKLESS_PRINCIPAL_set);
  SWIG_addvarlink(globals, "InstrmtAssignmentMethod_RANDOM", Swig_var_InstrmtAssignmentMethod_RANDOM_get, Swig_var_InstrmtAssignmentMethod_RANDOM_set);
  SWIG_addvarlink(globals, "InstrmtAssignmentMethod_PRO_RATA", Swig_var_InstrmtAssignmentMethod_PRO_RATA_get, Swig_var_InstrmtAssignmentMethod_PRO_RATA_set);
  SWIG_addvarlink(globals, "AggressorIndicator_YES", Swig_var_AggressorIndicator_YES_get, Swig_var_AggressorIndicator_YES_set);
  SWIG_addvarlink(globals, "AggressorIndicator_NO", Swig_var_AggressorIndicator_NO_get, Swig_var_AggressorIndicator_NO_set);
  SWIG_addvarlink(globals, "MDQuoteType_INDICATIVE", Swig_var_MDQuoteType_INDICATIVE_get, Swig_var_MDQuoteType_INDICATIVE_set);
  SWIG_addvarlink(globals, "MDQuoteType_TRADEABLE", Swig_var_MDQuoteType_TRADEABLE_get, Swig_var_MDQuoteType_TRADEABLE_set);
  SWIG_addvarlink(globals, "MDQuoteType_RESTRICTED_TRADEABLE", Swig_var_MDQuoteType_RESTRICTED_TRADEABLE_get, Swig_var_MDQuoteType_RESTRICTED_TRADEABLE_set);
  SWIG_addvarlink(globals, "MDQuoteType_COUNTER", Swig_var_MDQuoteType_COUNTER_get, Swig_var_MDQuoteType_COUNTER_set);
  SWIG_addvarlink(globals, "MDQuoteType_INDICATIVE_AND_TRADEABLE", Swig_var_MDQuoteType_INDICATIVE_AND_TRADEABLE_get, Swig_var_MDQuoteType_INDICATIVE_AND_TRADEABLE_set);
  SWIG_addvarlink(globals, "RefOrderIDSource_SECONDARY_ORDER_ID", Swig_var_RefOrderIDSource_SECONDARY_ORDER_ID_get, Swig_var_RefOrderIDSource_SECONDARY_ORDER_ID_set);
  SWIG_addvarlink(globals, "RefOrderIDSource_ORDER_ID", Swig_var_RefOrderIDSource_ORDER_ID_get, Swig_var_RefOrderIDSource_ORDER_ID_set);
  SWIG_addvarlink(globals, "RefOrderIDSource_MD_ENTRY_ID", Swig_var_RefOrderIDSource_MD_ENTRY_ID_get, Swig_var_RefOrderIDSource_MD_ENTRY_ID_set);
  SWIG_addvarlink(globals, "RefOrderIDSource_QUOTE_ENTRY_ID", Swig_var_RefOrderIDSource_QUOTE_ENTRY_ID_get, Swig_var_RefOrderIDSource_QUOTE_ENTRY_ID_set);
  SWIG_addvarlink(globals, "RefOrderIDSource_ORIGINAL_ORDER_ID", Swig_var_RefOrderIDSource_ORIGINAL_ORDER_ID_get, Swig_var_RefOrderIDSource_ORIGINAL_ORDER_ID_set);
  SWIG_addvarlink(globals, "RefOrderIDSource_QUOTE_ID", Swig_var_RefOrderIDSource_QUOTE_ID_get, Swig_var_RefOrderIDSource_QUOTE_ID_set);
  SWIG_addvarlink(globals, "RefOrderIDSource_QUOTE_REQ_ID", Swig_var_RefOrderIDSource_QUOTE_REQ_ID_get, Swig_var_RefOrderIDSource_QUOTE_REQ_ID_set);
  SWIG_addvarlink(globals, "RefOrderIDSource_PREVIOUS_ORDER_IDENTIFIER", Swig_var_RefOrderIDSource_PREVIOUS_ORDER_IDENTIFIER_get, Swig_var_RefOrderIDSource_PREVIOUS_ORDER_IDENTIFIER_set);
  SWIG_addvarlink(globals, "RefOrderIDSource_PREVIOUS_QUOTE_IDENTIFIER", Swig_var_RefOrderIDSource_PREVIOUS_QUOTE_IDENTIFIER_get, Swig_var_RefOrderIDSource_PREVIOUS_QUOTE_IDENTIFIER_set);
  SWIG_addvarlink(globals, "RefOrderIDSource_PARENT_ORDER_IDENTIFIER", Swig_var_RefOrderIDSource_PARENT_ORDER_IDENTIFIER_get, Swig_var_RefOrderIDSource_PARENT_ORDER_IDENTIFIER_set);
  SWIG_addvarlink(globals, "RefOrderIDSource_MANUAL_ORDER_IDENTIFIER", Swig_var_RefOrderIDSource_MANUAL_ORDER_IDENTIFIER_get, Swig_var_RefOrderIDSource_MANUAL_ORDER_IDENTIFIER_set);
  SWIG_addvarlink(globals, "DisplayWhen_IMMEDIATE", Swig_var_DisplayWhen_IMMEDIATE_get, Swig_var_DisplayWhen_IMMEDIATE_set);
  SWIG_addvarlink(globals, "DisplayWhen_EXHAUST", Swig_var_DisplayWhen_EXHAUST_get, Swig_var_DisplayWhen_EXHAUST_set);
  SWIG_addvarlink(globals, "DisplayMethod_INITIAL", Swig_var_DisplayMethod_INITIAL_get, Swig_var_DisplayMethod_INITIAL_set);
  SWIG_addvarlink(globals, "DisplayMethod_NEW", Swig_var_DisplayMethod_NEW_get, Swig_var_DisplayMethod_NEW_set);
  SWIG_addvarlink(globals, "DisplayMethod_RANDOM", Swig_var_DisplayMethod_RANDOM_get, Swig_var_DisplayMethod_RANDOM_set);
  SWIG_addvarlink(globals, "DisplayMethod_UNDISCLOSED", Swig_var_DisplayMethod_UNDISCLOSED_get, Swig_var_DisplayMethod_UNDISCLOSED_set);
  SWIG_addvarlink(globals, "PriceProtectionScope_NONE", Swig_var_PriceProtectionScope_NONE_get, Swig_var_PriceProtectionScope_NONE_set);
  SWIG_addvarlink(globals, "PriceProtectionScope_LOCAL", Swig_var_PriceProtectionScope_LOCAL_get, Swig_var_PriceProtectionScope_LOCAL_set);
  SWIG_addvarlink(globals, "PriceProtectionScope_NATIONAL", Swig_var_PriceProtectionScope_NATIONAL_get, Swig_var_PriceProtectionScope_NATIONAL_set);
  SWIG_addvarlink(globals, "PriceProtectionScope_GLOBAL", Swig_var_PriceProtectionScope_GLOBAL_get, Swig_var_PriceProtectionScope_GLOBAL_set);
  SWIG_addvarlink(globals, "LotType_ODD_LOT", Swig_var_LotType_ODD_LOT_get, Swig_var_LotType_ODD_LOT_set);
  SWIG_addvarlink(globals, "LotType_ROUND_LOT", Swig_var_LotType_ROUND_LOT_get, Swig_var_LotType_ROUND_LOT_set);
  SWIG_addvarlink(globals, "LotType_BLOCK_LOT", Swig_var_LotType_BLOCK_LOT_get, Swig_var_LotType_BLOCK_LOT_set);
  SWIG_addvarlink(globals, "LotType_ROUND_LOT_BASED_UPON", Swig_var_LotType_ROUND_LOT_BASED_UPON_get, Swig_var_LotType_ROUND_LOT_BASED_UPON_set);
  SWIG_addvarlink(globals, "PegPriceType_LAST_PEG", Swig_var_PegPriceType_LAST_PEG_get, Swig_var_PegPriceType_LAST_PEG_set);
  SWIG_addvarlink(globals, "PegPriceType_MID_PRICE_PEG", Swig_var_PegPriceType_MID_PRICE_PEG_get, Swig_var_PegPriceType_MID_PRICE_PEG_set);
  SWIG_addvarlink(globals, "PegPriceType_OPENING_PEG", Swig_var_PegPriceType_OPENING_PEG_get, Swig_var_PegPriceType_OPENING_PEG_set);
  SWIG_addvarlink(globals, "PegPriceType_MARKET_PEG", Swig_var_PegPriceType_MARKET_PEG_get, Swig_var_PegPriceType_MARKET_PEG_set);
  SWIG_addvarlink(globals, "PegPriceType_PRIMARY_PEG", Swig_var_PegPriceType_PRIMARY_PEG_get, Swig_var_PegPriceType_PRIMARY_PEG_set);
  SWIG_addvarlink(globals, "PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER", Swig_var_PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get, Swig_var_PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_set);
  SWIG_addvarlink(globals, "PegPriceType_PEG_TO_VWAP", Swig_var_PegPriceType_PEG_TO_VWAP_get, Swig_var_PegPriceType_PEG_TO_VWAP_set);
  SWIG_addvarlink(globals, "PegPriceType_TRAILING_STOP_PEG", Swig_var_PegPriceType_TRAILING_STOP_PEG_get, Swig_var_PegPriceType_TRAILING_STOP_PEG_set);
  SWIG_addvarlink(globals, "PegPriceType_PEG_TO_LIMIT_PRICE", Swig_var_PegPriceType_PEG_TO_LIMIT_PRICE_get, Swig_var_PegPriceType_PEG_TO_LIMIT_PRICE_set);
  SWIG_addvarlink(globals, "PegPriceType_SHORT_SALE_MIN_PRICE_PEG", Swig_var_PegPriceType_SHORT_SALE_MIN_PRICE_PEG_get, Swig_var_PegPriceType_SHORT_SALE_MIN_PRICE_PEG_set);
  SWIG_addvarlink(globals, "TriggerType_PARTIAL_EXECUTION", Swig_var_TriggerType_PARTIAL_EXECUTION_get, Swig_var_TriggerType_PARTIAL_EXECUTION_set);
  SWIG_addvarlink(globals, "TriggerType_SPECIFIED_TRADING_SESSION", Swig_var_TriggerType_SPECIFIED_TRADING_SESSION_get, Swig_var_TriggerType_SPECIFIED_TRADING_SESSION_set);
  SWIG_addvarlink(globals, "TriggerType_NEXT_AUCTION", Swig_var_TriggerType_NEXT_AUCTION_get, Swig_var_TriggerType_NEXT_AUCTION_set);
  SWIG_addvarlink(globals, "TriggerType_PRICE_MOVEMENT", Swig_var_TriggerType_PRICE_MOVEMENT_get, Swig_var_TriggerType_PRICE_MOVEMENT_set);
  SWIG_addvarlink(globals, "TriggerType_ON_ORDER_ENTRY_OR_MODIFICATION", Swig_var_TriggerType_ON_ORDER_ENTRY_OR_MODIFICATION_get, Swig_var_TriggerType_ON_ORDER_ENTRY_OR_MODIFICATION_set);
  SWIG_addvarlink(globals, "TriggerAction_ACTIVATE", Swig_var_TriggerAction_ACTIVATE_get, Swig_var_TriggerAction_ACTIVATE_set);
  SWIG_addvarlink(globals, "TriggerAction_MODIFY", Swig_var_TriggerAction_MODIFY_get, Swig_var_TriggerAction_MODIFY_set);
  SWIG_addvarlink(globals, "TriggerAction_CANCEL", Swig_var_TriggerAction_CANCEL_get, Swig_var_TriggerAction_CANCEL_set);
  SWIG_addvarlink(globals, "TriggerPriceType_BEST_OFFER", Swig_var_TriggerPriceType_BEST_OFFER_get, Swig_var_TriggerPriceType_BEST_OFFER_set);
  SWIG_addvarlink(globals, "TriggerPriceType_LAST_TRADE", Swig_var_TriggerPriceType_LAST_TRADE_get, Swig_var_TriggerPriceType_LAST_TRADE_set);
  SWIG_addvarlink(globals, "TriggerPriceType_BEST_BID", Swig_var_TriggerPriceType_BEST_BID_get, Swig_var_TriggerPriceType_BEST_BID_set);
  SWIG_addvarlink(globals, "TriggerPriceType_BEST_BID_OR_LAST_TRADE", Swig_var_TriggerPriceType_BEST_BID_OR_LAST_TRADE_get, Swig_var_TriggerPriceType_BEST_BID_OR_LAST_TRADE_set);
  SWIG_addvarlink(globals, "TriggerPriceType_BEST_OFFER_OR_LAST_TRADE", Swig_var_TriggerPriceType_BEST_OFFER_OR_LAST_TRADE_get, Swig_var_TriggerPriceType_BEST_OFFER_OR_LAST_TRADE_set);
  SWIG_addvarlink(globals, "TriggerPriceType_BEST_MID", Swig_var_TriggerPriceType_BEST_MID_get, Swig_var_TriggerPriceType_BEST_MID_set);
  SWIG_addvarlink(globals, "TriggerPriceTypeScope_NONE", Swig_var_TriggerPriceTypeScope_NONE_get, Swig_var_TriggerPriceTypeScope_NONE_set);
  SWIG_addvarlink(globals, "TriggerPriceTypeScope_LOCAL", Swig_var_TriggerPriceTypeScope_LOCAL_get, Swig_var_TriggerPriceTypeScope_LOCAL_set);
  SWIG_addvarlink(globals, "TriggerPriceTypeScope_NATIONAL", Swig_var_TriggerPriceTypeScope_NATIONAL_get, Swig_var_TriggerPriceTypeScope_NATIONAL_set);
  SWIG_addvarlink(globals, "TriggerPriceTypeScope_GLOBAL", Swig_var_TriggerPriceTypeScope_GLOBAL_get, Swig_var_TriggerPriceTypeScope_GLOBAL_set);
  SWIG_addvarlink(globals, "TriggerPriceDirection_UP", Swig_var_TriggerPriceDirection_UP_get, Swig_var_TriggerPriceDirection_UP_set);
  SWIG_addvarlink(globals, "TriggerPriceDirection_DOWN", Swig_var_TriggerPriceDirection_DOWN_get, Swig_var_TriggerPriceDirection_DOWN_set);
  SWIG_addvarlink(globals, "TriggerOrderType_MARKET", Swig_var_TriggerOrderType_MARKET_get, Swig_var_TriggerOrderType_MARKET_set);
  SWIG_addvarlink(globals, "TriggerOrderType_LIMIT", Swig_var_TriggerOrderType_LIMIT_get, Swig_var_TriggerOrderType_LIMIT_set);
  SWIG_addvarlink(globals, "OrderCategory_ORDER", Swig_var_OrderCategory_ORDER_get, Swig_var_OrderCategory_ORDER_set);
  SWIG_addvarlink(globals, "OrderCategory_QUOTE", Swig_var_OrderCategory_QUOTE_get, Swig_var_OrderCategory_QUOTE_set);
  SWIG_addvarlink(globals, "OrderCategory_PRIVATELY_NEGOTIATED_TRADE", Swig_var_OrderCategory_PRIVATELY_NEGOTIATED_TRADE_get, Swig_var_OrderCategory_PRIVATELY_NEGOTIATED_TRADE_set);
  SWIG_addvarlink(globals, "OrderCategory_MULTILEG_ORDER", Swig_var_OrderCategory_MULTILEG_ORDER_get, Swig_var_OrderCategory_MULTILEG_ORDER_set);
  SWIG_addvarlink(globals, "OrderCategory_LINKED_ORDER", Swig_var_OrderCategory_LINKED_ORDER_get, Swig_var_OrderCategory_LINKED_ORDER_set);
  SWIG_addvarlink(globals, "OrderCategory_QUOTE_REQUEST", Swig_var_OrderCategory_QUOTE_REQUEST_get, Swig_var_OrderCategory_QUOTE_REQUEST_set);
  SWIG_addvarlink(globals, "OrderCategory_IMPLIED_ORDER", Swig_var_OrderCategory_IMPLIED_ORDER_get, Swig_var_OrderCategory_IMPLIED_ORDER_set);
  SWIG_addvarlink(globals, "OrderCategory_CROSS_ORDER", Swig_var_OrderCategory_CROSS_ORDER_get, Swig_var_OrderCategory_CROSS_ORDER_set);
  SWIG_addvarlink(globals, "OrderCategory_STREAMING_PRICE", Swig_var_OrderCategory_STREAMING_PRICE_get, Swig_var_OrderCategory_STREAMING_PRICE_set);
  SWIG_addvarlink(globals, "OrderCategory_INTERNAL_CROSS_ORDER", Swig_var_OrderCategory_INTERNAL_CROSS_ORDER_get, Swig_var_OrderCategory_INTERNAL_CROSS_ORDER_set);
  SWIG_addvarlink(globals, "TradeHandlingInstr_TRADE_CONFIRMATION", Swig_var_TradeHandlingInstr_TRADE_CONFIRMATION_get, Swig_var_TradeHandlingInstr_TRADE_CONFIRMATION_set);
  SWIG_addvarlink(globals, "TradeHandlingInstr_TWO_PARTY_REPORT", Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_get, Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_set);
  SWIG_addvarlink(globals, "TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING", Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING_get, Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING_set);
  SWIG_addvarlink(globals, "TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH", Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH_get, Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH_set);
  SWIG_addvarlink(globals, "TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING", Swig_var_TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING_get, Swig_var_TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING_set);
  SWIG_addvarlink(globals, "TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM", Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM_get, Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM_set);
  SWIG_addvarlink(globals, "TradeHandlingInstr_ONE_PARTY_REPORT", Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_get, Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_set);
  SWIG_addvarlink(globals, "TradeHandlingInstr_THIRD_PTY_RPT_FOR_PASS_THROUGH", Swig_var_TradeHandlingInstr_THIRD_PTY_RPT_FOR_PASS_THROUGH_get, Swig_var_TradeHandlingInstr_THIRD_PTY_RPT_FOR_PASS_THROUGH_set);
  SWIG_addvarlink(globals, "TradeHandlingInstr_ONE_PARTY_REPORT_AUTO_MATCH", Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_AUTO_MATCH_get, Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_AUTO_MATCH_set);
  SWIG_addvarlink(globals, "ExDestinationIDSource_BIC", Swig_var_ExDestinationIDSource_BIC_get, Swig_var_ExDestinationIDSource_BIC_set);
  SWIG_addvarlink(globals, "ExDestinationIDSource_GENERAL_IDENTIFIER", Swig_var_ExDestinationIDSource_GENERAL_IDENTIFIER_get, Swig_var_ExDestinationIDSource_GENERAL_IDENTIFIER_set);
  SWIG_addvarlink(globals, "ExDestinationIDSource_PROPRIETARY", Swig_var_ExDestinationIDSource_PROPRIETARY_get, Swig_var_ExDestinationIDSource_PROPRIETARY_set);
  SWIG_addvarlink(globals, "ExDestinationIDSource_ISO_COUNTRY_CODE", Swig_var_ExDestinationIDSource_ISO_COUNTRY_CODE_get, Swig_var_ExDestinationIDSource_ISO_COUNTRY_CODE_set);
  SWIG_addvarlink(globals, "ExDestinationIDSource_MIC", Swig_var_ExDestinationIDSource_MIC_get, Swig_var_ExDestinationIDSource_MIC_set);
  SWIG_addvarlink(globals, "ExpirationQtyType_AUTO_EXERCISE", Swig_var_ExpirationQtyType_AUTO_EXERCISE_get, Swig_var_ExpirationQtyType_AUTO_EXERCISE_set);
  SWIG_addvarlink(globals, "ExpirationQtyType_NON_AUTO_EXERCISE", Swig_var_ExpirationQtyType_NON_AUTO_EXERCISE_get, Swig_var_ExpirationQtyType_NON_AUTO_EXERCISE_set);
  SWIG_addvarlink(globals, "ExpirationQtyType_FINAL_WILL_BE_EXERCISED", Swig_var_ExpirationQtyType_FINAL_WILL_BE_EXERCISED_get, Swig_var_ExpirationQtyType_FINAL_WILL_BE_EXERCISED_set);
  SWIG_addvarlink(globals, "ExpirationQtyType_CONTRARY_INTENTION", Swig_var_ExpirationQtyType_CONTRARY_INTENTION_get, Swig_var_ExpirationQtyType_CONTRARY_INTENTION_set);
  SWIG_addvarlink(globals, "ExpirationQtyType_DIFFERENCE", Swig_var_ExpirationQtyType_DIFFERENCE_get, Swig_var_ExpirationQtyType_DIFFERENCE_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_BILLION_CUBIC_FEET", Swig_var_UnitOfMeasure_BILLION_CUBIC_FEET_get, Swig_var_UnitOfMeasure_BILLION_CUBIC_FEET_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_MILLION_BARRELS", Swig_var_UnitOfMeasure_MILLION_BARRELS_get, Swig_var_UnitOfMeasure_MILLION_BARRELS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_ONE_MILLION_BTU", Swig_var_UnitOfMeasure_ONE_MILLION_BTU_get, Swig_var_UnitOfMeasure_ONE_MILLION_BTU_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_MEGAWATT_HOURS", Swig_var_UnitOfMeasure_MEGAWATT_HOURS_get, Swig_var_UnitOfMeasure_MEGAWATT_HOURS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_BARRELS", Swig_var_UnitOfMeasure_BARRELS_get, Swig_var_UnitOfMeasure_BARRELS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_BUSHELS", Swig_var_UnitOfMeasure_BUSHELS_get, Swig_var_UnitOfMeasure_BUSHELS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_POUNDS", Swig_var_UnitOfMeasure_POUNDS_get, Swig_var_UnitOfMeasure_POUNDS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_GALLONS", Swig_var_UnitOfMeasure_GALLONS_get, Swig_var_UnitOfMeasure_GALLONS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_TROY_OUNCES", Swig_var_UnitOfMeasure_TROY_OUNCES_get, Swig_var_UnitOfMeasure_TROY_OUNCES_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_METRIC_TONS", Swig_var_UnitOfMeasure_METRIC_TONS_get, Swig_var_UnitOfMeasure_METRIC_TONS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_TONS", Swig_var_UnitOfMeasure_TONS_get, Swig_var_UnitOfMeasure_TONS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_US_DOLLARS", Swig_var_UnitOfMeasure_US_DOLLARS_get, Swig_var_UnitOfMeasure_US_DOLLARS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_CUBIC_METERS", Swig_var_UnitOfMeasure_CUBIC_METERS_get, Swig_var_UnitOfMeasure_CUBIC_METERS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_GIGAJOULES", Swig_var_UnitOfMeasure_GIGAJOULES_get, Swig_var_UnitOfMeasure_GIGAJOULES_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_HEAT_RATE", Swig_var_UnitOfMeasure_HEAT_RATE_get, Swig_var_UnitOfMeasure_HEAT_RATE_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_KILOWATT_HOURS", Swig_var_UnitOfMeasure_KILOWATT_HOURS_get, Swig_var_UnitOfMeasure_KILOWATT_HOURS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_MEGA_HEAT_RATE", Swig_var_UnitOfMeasure_MEGA_HEAT_RATE_get, Swig_var_UnitOfMeasure_MEGA_HEAT_RATE_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_THERMS", Swig_var_UnitOfMeasure_THERMS_get, Swig_var_UnitOfMeasure_THERMS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_TONS_OF_CARBON_DIOXIDE", Swig_var_UnitOfMeasure_TONS_OF_CARBON_DIOXIDE_get, Swig_var_UnitOfMeasure_TONS_OF_CARBON_DIOXIDE_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_ALLOWANCES", Swig_var_UnitOfMeasure_ALLOWANCES_get, Swig_var_UnitOfMeasure_ALLOWANCES_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_BOARD_FEET", Swig_var_UnitOfMeasure_BOARD_FEET_get, Swig_var_UnitOfMeasure_BOARD_FEET_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_CURRENCY", Swig_var_UnitOfMeasure_CURRENCY_get, Swig_var_UnitOfMeasure_CURRENCY_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_COOLING_DEGREE_DAY", Swig_var_UnitOfMeasure_COOLING_DEGREE_DAY_get, Swig_var_UnitOfMeasure_COOLING_DEGREE_DAY_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_CERTIFIED_EMISSIONS_REDUCTION", Swig_var_UnitOfMeasure_CERTIFIED_EMISSIONS_REDUCTION_get, Swig_var_UnitOfMeasure_CERTIFIED_EMISSIONS_REDUCTION_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_CRITICAL_PRECIP_DAY", Swig_var_UnitOfMeasure_CRITICAL_PRECIP_DAY_get, Swig_var_UnitOfMeasure_CRITICAL_PRECIP_DAY_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_CLIMATE_RESERVE_TONNES", Swig_var_UnitOfMeasure_CLIMATE_RESERVE_TONNES_get, Swig_var_UnitOfMeasure_CLIMATE_RESERVE_TONNES_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_HUNDREDWEIGHT", Swig_var_UnitOfMeasure_HUNDREDWEIGHT_get, Swig_var_UnitOfMeasure_HUNDREDWEIGHT_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_DAY", Swig_var_UnitOfMeasure_DAY_get, Swig_var_UnitOfMeasure_DAY_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_DRY_METRIC_TONS", Swig_var_UnitOfMeasure_DRY_METRIC_TONS_get, Swig_var_UnitOfMeasure_DRY_METRIC_TONS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_ENV_ALLWNC_CERT", Swig_var_UnitOfMeasure_ENV_ALLWNC_CERT_get, Swig_var_UnitOfMeasure_ENV_ALLWNC_CERT_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_ENVIRONMENTAL_CREDIT", Swig_var_UnitOfMeasure_ENVIRONMENTAL_CREDIT_get, Swig_var_UnitOfMeasure_ENVIRONMENTAL_CREDIT_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_ENVIRONMENTAL_OFFSET", Swig_var_UnitOfMeasure_ENVIRONMENTAL_OFFSET_get, Swig_var_UnitOfMeasure_ENVIRONMENTAL_OFFSET_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_GRAMS", Swig_var_UnitOfMeasure_GRAMS_get, Swig_var_UnitOfMeasure_GRAMS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_GROSS_TONS", Swig_var_UnitOfMeasure_GROSS_TONS_get, Swig_var_UnitOfMeasure_GROSS_TONS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_HEATING_DEGREE_DAY", Swig_var_UnitOfMeasure_HEATING_DEGREE_DAY_get, Swig_var_UnitOfMeasure_HEATING_DEGREE_DAY_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_INDEX_POINT", Swig_var_UnitOfMeasure_INDEX_POINT_get, Swig_var_UnitOfMeasure_INDEX_POINT_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_KILOGRAMS", Swig_var_UnitOfMeasure_KILOGRAMS_get, Swig_var_UnitOfMeasure_KILOGRAMS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_KILOLITERS", Swig_var_UnitOfMeasure_KILOLITERS_get, Swig_var_UnitOfMeasure_KILOLITERS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_KILOWATT_YEAR", Swig_var_UnitOfMeasure_KILOWATT_YEAR_get, Swig_var_UnitOfMeasure_KILOWATT_YEAR_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_KILOWATT_DAY", Swig_var_UnitOfMeasure_KILOWATT_DAY_get, Swig_var_UnitOfMeasure_KILOWATT_DAY_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_KILOWATT_HOUR", Swig_var_UnitOfMeasure_KILOWATT_HOUR_get, Swig_var_UnitOfMeasure_KILOWATT_HOUR_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_KILOWATT_MONTH", Swig_var_UnitOfMeasure_KILOWATT_MONTH_get, Swig_var_UnitOfMeasure_KILOWATT_MONTH_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_KILOWATT_MINUTE", Swig_var_UnitOfMeasure_KILOWATT_MINUTE_get, Swig_var_UnitOfMeasure_KILOWATT_MINUTE_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_LITERS", Swig_var_UnitOfMeasure_LITERS_get, Swig_var_UnitOfMeasure_LITERS_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_MEGAWATT_YEAR", Swig_var_UnitOfMeasure_MEGAWATT_YEAR_get, Swig_var_UnitOfMeasure_MEGAWATT_YEAR_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_MEGAWATT_DAY", Swig_var_UnitOfMeasure_MEGAWATT_DAY_get, Swig_var_UnitOfMeasure_MEGAWATT_DAY_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_MEGAWATT_HOUR", Swig_var_UnitOfMeasure_MEGAWATT_HOUR_get, Swig_var_UnitOfMeasure_MEGAWATT_HOUR_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_MEGAWATT_MONTH", Swig_var_UnitOfMeasure_MEGAWATT_MONTH_get, Swig_var_UnitOfMeasure_MEGAWATT_MONTH_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_MEGAWATT_MINUTE", Swig_var_UnitOfMeasure_MEGAWATT_MINUTE_get, Swig_var_UnitOfMeasure_MEGAWATT_MINUTE_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_PRINCIPAL_WITH_RELATION_TO_DEBT_INSTRUMENT", Swig_var_UnitOfMeasure_PRINCIPAL_WITH_RELATION_TO_DEBT_INSTRUMENT_get, Swig_var_UnitOfMeasure_PRINCIPAL_WITH_RELATION_TO_DEBT_INSTRUMENT_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_ARE", Swig_var_UnitOfMeasure_ARE_get, Swig_var_UnitOfMeasure_ARE_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_ACRE", Swig_var_UnitOfMeasure_ACRE_get, Swig_var_UnitOfMeasure_ACRE_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_CENTILITER", Swig_var_UnitOfMeasure_CENTILITER_get, Swig_var_UnitOfMeasure_CENTILITER_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_CENTIMETER", Swig_var_UnitOfMeasure_CENTIMETER_get, Swig_var_UnitOfMeasure_CENTIMETER_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_DIESEL_GALLON_EQUIVALENT", Swig_var_UnitOfMeasure_DIESEL_GALLON_EQUIVALENT_get, Swig_var_UnitOfMeasure_DIESEL_GALLON_EQUIVALENT_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_FOOT", Swig_var_UnitOfMeasure_FOOT_get, Swig_var_UnitOfMeasure_FOOT_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_GB_GALLON", Swig_var_UnitOfMeasure_GB_GALLON_get, Swig_var_UnitOfMeasure_GB_GALLON_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_GASOLINE_GALLON_EQUIVALENT", Swig_var_UnitOfMeasure_GASOLINE_GALLON_EQUIVALENT_get, Swig_var_UnitOfMeasure_GASOLINE_GALLON_EQUIVALENT_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_HECTARE", Swig_var_UnitOfMeasure_HECTARE_get, Swig_var_UnitOfMeasure_HECTARE_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_INCH", Swig_var_UnitOfMeasure_INCH_get, Swig_var_UnitOfMeasure_INCH_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_KILOMETER", Swig_var_UnitOfMeasure_KILOMETER_get, Swig_var_UnitOfMeasure_KILOMETER_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_METER", Swig_var_UnitOfMeasure_METER_get, Swig_var_UnitOfMeasure_METER_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_MILE", Swig_var_UnitOfMeasure_MILE_get, Swig_var_UnitOfMeasure_MILE_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_MILLILITER", Swig_var_UnitOfMeasure_MILLILITER_get, Swig_var_UnitOfMeasure_MILLILITER_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_MILLIMETER", Swig_var_UnitOfMeasure_MILLIMETER_get, Swig_var_UnitOfMeasure_MILLIMETER_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_US_OUNCE", Swig_var_UnitOfMeasure_US_OUNCE_get, Swig_var_UnitOfMeasure_US_OUNCE_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_PIECE", Swig_var_UnitOfMeasure_PIECE_get, Swig_var_UnitOfMeasure_PIECE_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_US_PINT", Swig_var_UnitOfMeasure_US_PINT_get, Swig_var_UnitOfMeasure_US_PINT_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_GB_PINT", Swig_var_UnitOfMeasure_GB_PINT_get, Swig_var_UnitOfMeasure_GB_PINT_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_US_QUART", Swig_var_UnitOfMeasure_US_QUART_get, Swig_var_UnitOfMeasure_US_QUART_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_GB_QUART", Swig_var_UnitOfMeasure_GB_QUART_get, Swig_var_UnitOfMeasure_GB_QUART_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_SQUARE_CENTIMETER", Swig_var_UnitOfMeasure_SQUARE_CENTIMETER_get, Swig_var_UnitOfMeasure_SQUARE_CENTIMETER_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_SQUARE_FOOT", Swig_var_UnitOfMeasure_SQUARE_FOOT_get, Swig_var_UnitOfMeasure_SQUARE_FOOT_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_SQUARE_INCH", Swig_var_UnitOfMeasure_SQUARE_INCH_get, Swig_var_UnitOfMeasure_SQUARE_INCH_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_SQUARE_KILOMETER", Swig_var_UnitOfMeasure_SQUARE_KILOMETER_get, Swig_var_UnitOfMeasure_SQUARE_KILOMETER_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_SQUARE_METER", Swig_var_UnitOfMeasure_SQUARE_METER_get, Swig_var_UnitOfMeasure_SQUARE_METER_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_SQUARE_MILE", Swig_var_UnitOfMeasure_SQUARE_MILE_get, Swig_var_UnitOfMeasure_SQUARE_MILE_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_SQUARE_MILLIMETER", Swig_var_UnitOfMeasure_SQUARE_MILLIMETER_get, Swig_var_UnitOfMeasure_SQUARE_MILLIMETER_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_SQUARE_YARD", Swig_var_UnitOfMeasure_SQUARE_YARD_get, Swig_var_UnitOfMeasure_SQUARE_YARD_set);
  SWIG_addvarlink(globals, "UnitOfMeasure_YARD", Swig_var_UnitOfMeasure_YARD_get, Swig_var_UnitOfMeasure_YARD_set);
  SWIG_addvarlink(globals, "ImpliedMarketIndicator_NOT_IMPLIED", Swig_var_ImpliedMarketIndicator_NOT_IMPLIED_get, Swig_var_ImpliedMarketIndicator_NOT_IMPLIED_set);
  SWIG_addvarlink(globals, "ImpliedMarketIndicator_IMPLIED_IN", Swig_var_ImpliedMarketIndicator_IMPLIED_IN_get, Swig_var_ImpliedMarketIndicator_IMPLIED_IN_set);
  SWIG_addvarlink(globals, "ImpliedMarketIndicator_IMPLIED_OUT", Swig_var_ImpliedMarketIndicator_IMPLIED_OUT_get, Swig_var_ImpliedMarketIndicator_IMPLIED_OUT_set);
  SWIG_addvarlink(globals, "ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT", Swig_var_ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT_get, Swig_var_ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT_set);
  SWIG_addvarlink(globals, "SettlObligMode_PRELIMINARY", Swig_var_SettlObligMode_PRELIMINARY_get, Swig_var_SettlObligMode_PRELIMINARY_set);
  SWIG_addvarlink(globals, "SettlObligMode_FINAL", Swig_var_SettlObligMode_FINAL_get, Swig_var_SettlObligMode_FINAL_set);
  SWIG_addvarlink(globals, "SettlObligTransType_CANCEL", Swig_var_SettlObligTransType_CANCEL_get, Swig_var_SettlObligTransType_CANCEL_set);
  SWIG_addvarlink(globals, "SettlObligTransType_NEW", Swig_var_SettlObligTransType_NEW_get, Swig_var_SettlObligTransType_NEW_set);
  SWIG_addvarlink(globals, "SettlObligTransType_REPLACE", Swig_var_SettlObligTransType_REPLACE_get, Swig_var_SettlObligTransType_REPLACE_set);
  SWIG_addvarlink(globals, "SettlObligTransType_RESTATE", Swig_var_SettlObligTransType_RESTATE_get, Swig_var_SettlObligTransType_RESTATE_set);
  SWIG_addvarlink(globals, "SettlObligSource_INSTRUCTIONS_OF_BROKER", Swig_var_SettlObligSource_INSTRUCTIONS_OF_BROKER_get, Swig_var_SettlObligSource_INSTRUCTIONS_OF_BROKER_set);
  SWIG_addvarlink(globals, "SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION", Swig_var_SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION_get, Swig_var_SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION_set);
  SWIG_addvarlink(globals, "SettlObligSource_INVESTOR", Swig_var_SettlObligSource_INVESTOR_get, Swig_var_SettlObligSource_INVESTOR_set);
  SWIG_addvarlink(globals, "SettlObligSource_BUYERS_SETTLEMENT_INSTRUCTIONS", Swig_var_SettlObligSource_BUYERS_SETTLEMENT_INSTRUCTIONS_get, Swig_var_SettlObligSource_BUYERS_SETTLEMENT_INSTRUCTIONS_set);
  SWIG_addvarlink(globals, "SettlObligSource_SELLERS_SETTLEMENT_INSTRUCTIONS", Swig_var_SettlObligSource_SELLERS_SETTLEMENT_INSTRUCTIONS_get, Swig_var_SettlObligSource_SELLERS_SETTLEMENT_INSTRUCTIONS_set);
  SWIG_addvarlink(globals, "QuoteEntryStatus_ACCEPTED", Swig_var_QuoteEntryStatus_ACCEPTED_get, Swig_var_QuoteEntryStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "QuoteEntryStatus_REJECTED", Swig_var_QuoteEntryStatus_REJECTED_get, Swig_var_QuoteEntryStatus_REJECTED_set);
  SWIG_addvarlink(globals, "QuoteEntryStatus_REMOVED_FROM_MARKET", Swig_var_QuoteEntryStatus_REMOVED_FROM_MARKET_get, Swig_var_QuoteEntryStatus_REMOVED_FROM_MARKET_set);
  SWIG_addvarlink(globals, "QuoteEntryStatus_EXPIRED", Swig_var_QuoteEntryStatus_EXPIRED_get, Swig_var_QuoteEntryStatus_EXPIRED_set);
  SWIG_addvarlink(globals, "QuoteEntryStatus_LOCKED_MARKET_WARNING", Swig_var_QuoteEntryStatus_LOCKED_MARKET_WARNING_get, Swig_var_QuoteEntryStatus_LOCKED_MARKET_WARNING_set);
  SWIG_addvarlink(globals, "QuoteEntryStatus_CROSS_MARKET_WARNING", Swig_var_QuoteEntryStatus_CROSS_MARKET_WARNING_get, Swig_var_QuoteEntryStatus_CROSS_MARKET_WARNING_set);
  SWIG_addvarlink(globals, "QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET", Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET_get, Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET_set);
  SWIG_addvarlink(globals, "QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET", Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET_get, Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET_set);
  SWIG_addvarlink(globals, "QuoteEntryStatus_ACTIVE", Swig_var_QuoteEntryStatus_ACTIVE_get, Swig_var_QuoteEntryStatus_ACTIVE_set);
  SWIG_addvarlink(globals, "PrivateQuote_YES", Swig_var_PrivateQuote_YES_get, Swig_var_PrivateQuote_YES_set);
  SWIG_addvarlink(globals, "PrivateQuote_NO", Swig_var_PrivateQuote_NO_get, Swig_var_PrivateQuote_NO_set);
  SWIG_addvarlink(globals, "RespondentType_ALL_MARKET_PARTICIPANTS", Swig_var_RespondentType_ALL_MARKET_PARTICIPANTS_get, Swig_var_RespondentType_ALL_MARKET_PARTICIPANTS_set);
  SWIG_addvarlink(globals, "RespondentType_SPECIFIED_MARKET_PARTICIPANTS", Swig_var_RespondentType_SPECIFIED_MARKET_PARTICIPANTS_get, Swig_var_RespondentType_SPECIFIED_MARKET_PARTICIPANTS_set);
  SWIG_addvarlink(globals, "RespondentType_ALL_MARKET_MAKERS", Swig_var_RespondentType_ALL_MARKET_MAKERS_get, Swig_var_RespondentType_ALL_MARKET_MAKERS_set);
  SWIG_addvarlink(globals, "RespondentType_PRIMARY_MARKET_MAKER", Swig_var_RespondentType_PRIMARY_MARKET_MAKER_get, Swig_var_RespondentType_PRIMARY_MARKET_MAKER_set);
  SWIG_addvarlink(globals, "SecurityTradingEvent_ORDER_IMBALANCE", Swig_var_SecurityTradingEvent_ORDER_IMBALANCE_get, Swig_var_SecurityTradingEvent_ORDER_IMBALANCE_set);
  SWIG_addvarlink(globals, "SecurityTradingEvent_TRADING_RESUMES", Swig_var_SecurityTradingEvent_TRADING_RESUMES_get, Swig_var_SecurityTradingEvent_TRADING_RESUMES_set);
  SWIG_addvarlink(globals, "SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION", Swig_var_SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION_get, Swig_var_SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION_set);
  SWIG_addvarlink(globals, "SecurityTradingEvent_CHANGE_OF_TRADING_SESSION", Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SESSION_get, Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SESSION_set);
  SWIG_addvarlink(globals, "SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION", Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION_get, Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION_set);
  SWIG_addvarlink(globals, "SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS", Swig_var_SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS_get, Swig_var_SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS_set);
  SWIG_addvarlink(globals, "SecurityTradingEvent_CHANGE_OF_BOOK_TYPE", Swig_var_SecurityTradingEvent_CHANGE_OF_BOOK_TYPE_get, Swig_var_SecurityTradingEvent_CHANGE_OF_BOOK_TYPE_set);
  SWIG_addvarlink(globals, "SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH", Swig_var_SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH_get, Swig_var_SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH_set);
  SWIG_addvarlink(globals, "SecurityTradingEvent_CORPORATE_ACTION", Swig_var_SecurityTradingEvent_CORPORATE_ACTION_get, Swig_var_SecurityTradingEvent_CORPORATE_ACTION_set);
  SWIG_addvarlink(globals, "StatsType_EXCHANGE_LAST", Swig_var_StatsType_EXCHANGE_LAST_get, Swig_var_StatsType_EXCHANGE_LAST_set);
  SWIG_addvarlink(globals, "StatsType_HIGH", Swig_var_StatsType_HIGH_get, Swig_var_StatsType_HIGH_set);
  SWIG_addvarlink(globals, "StatsType_AVERAGE_PRICE", Swig_var_StatsType_AVERAGE_PRICE_get, Swig_var_StatsType_AVERAGE_PRICE_set);
  SWIG_addvarlink(globals, "StatsType_TURNOVER", Swig_var_StatsType_TURNOVER_get, Swig_var_StatsType_TURNOVER_set);
  SWIG_addvarlink(globals, "MDSecSizeType_CUSTOMER", Swig_var_MDSecSizeType_CUSTOMER_get, Swig_var_MDSecSizeType_CUSTOMER_set);
  SWIG_addvarlink(globals, "MDSecSizeType_CUSTOMER_PROFESSIONAL", Swig_var_MDSecSizeType_CUSTOMER_PROFESSIONAL_get, Swig_var_MDSecSizeType_CUSTOMER_PROFESSIONAL_set);
  SWIG_addvarlink(globals, "MDSecSizeType_DO_NOT_TRADE_THROUGH", Swig_var_MDSecSizeType_DO_NOT_TRADE_THROUGH_get, Swig_var_MDSecSizeType_DO_NOT_TRADE_THROUGH_set);
  SWIG_addvarlink(globals, "SettlMethod_CASH_SETTLEMENT_REQUIRED", Swig_var_SettlMethod_CASH_SETTLEMENT_REQUIRED_get, Swig_var_SettlMethod_CASH_SETTLEMENT_REQUIRED_set);
  SWIG_addvarlink(globals, "SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED", Swig_var_SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED_get, Swig_var_SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED_set);
  SWIG_addvarlink(globals, "SettlMethod_ELECTION", Swig_var_SettlMethod_ELECTION_get, Swig_var_SettlMethod_ELECTION_set);
  SWIG_addvarlink(globals, "ExerciseStyle_EUROPEAN", Swig_var_ExerciseStyle_EUROPEAN_get, Swig_var_ExerciseStyle_EUROPEAN_set);
  SWIG_addvarlink(globals, "ExerciseStyle_AMERICAN", Swig_var_ExerciseStyle_AMERICAN_get, Swig_var_ExerciseStyle_AMERICAN_set);
  SWIG_addvarlink(globals, "ExerciseStyle_BERMUDA", Swig_var_ExerciseStyle_BERMUDA_get, Swig_var_ExerciseStyle_BERMUDA_set);
  SWIG_addvarlink(globals, "ExerciseStyle_OTHER", Swig_var_ExerciseStyle_OTHER_get, Swig_var_ExerciseStyle_OTHER_set);
  SWIG_addvarlink(globals, "PriceQuoteMethod_STANDARD", Swig_var_PriceQuoteMethod_STANDARD_get, Swig_var_PriceQuoteMethod_STANDARD_set);
  SWIG_addvarlink(globals, "PriceQuoteMethod_INDEX", Swig_var_PriceQuoteMethod_INDEX_get, Swig_var_PriceQuoteMethod_INDEX_set);
  SWIG_addvarlink(globals, "PriceQuoteMethod_INTEREST_RATE_INDEX", Swig_var_PriceQuoteMethod_INTEREST_RATE_INDEX_get, Swig_var_PriceQuoteMethod_INTEREST_RATE_INDEX_set);
  SWIG_addvarlink(globals, "PriceQuoteMethod_PERCENT_OF_PAR", Swig_var_PriceQuoteMethod_PERCENT_OF_PAR_get, Swig_var_PriceQuoteMethod_PERCENT_OF_PAR_set);
  SWIG_addvarlink(globals, "FuturesValuationMethod_PREMIUM_STYLE", Swig_var_FuturesValuationMethod_PREMIUM_STYLE_get, Swig_var_FuturesValuationMethod_PREMIUM_STYLE_set);
  SWIG_addvarlink(globals, "FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET", Swig_var_FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get, Swig_var_FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_set);
  SWIG_addvarlink(globals, "FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT", Swig_var_FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get, Swig_var_FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_set);
  SWIG_addvarlink(globals, "ListMethod_PRE_LISTED_ONLY", Swig_var_ListMethod_PRE_LISTED_ONLY_get, Swig_var_ListMethod_PRE_LISTED_ONLY_set);
  SWIG_addvarlink(globals, "ListMethod_USER_REQUESTED", Swig_var_ListMethod_USER_REQUESTED_get, Swig_var_ListMethod_USER_REQUESTED_set);
  SWIG_addvarlink(globals, "TickRuleType_REGULAR", Swig_var_TickRuleType_REGULAR_get, Swig_var_TickRuleType_REGULAR_set);
  SWIG_addvarlink(globals, "TickRuleType_VARIABLE", Swig_var_TickRuleType_VARIABLE_get, Swig_var_TickRuleType_VARIABLE_set);
  SWIG_addvarlink(globals, "TickRuleType_FIXED", Swig_var_TickRuleType_FIXED_get, Swig_var_TickRuleType_FIXED_set);
  SWIG_addvarlink(globals, "TickRuleType_TRADED_AS_A_SPREAD_LEG", Swig_var_TickRuleType_TRADED_AS_A_SPREAD_LEG_get, Swig_var_TickRuleType_TRADED_AS_A_SPREAD_LEG_set);
  SWIG_addvarlink(globals, "TickRuleType_SETTLED_AS_A_SPREAD_LEG", Swig_var_TickRuleType_SETTLED_AS_A_SPREAD_LEG_get, Swig_var_TickRuleType_SETTLED_AS_A_SPREAD_LEG_set);
  SWIG_addvarlink(globals, "TickRuleType_REGULAR_TRADING", Swig_var_TickRuleType_REGULAR_TRADING_get, Swig_var_TickRuleType_REGULAR_TRADING_set);
  SWIG_addvarlink(globals, "TickRuleType_VARIABLE_CABINET", Swig_var_TickRuleType_VARIABLE_CABINET_get, Swig_var_TickRuleType_VARIABLE_CABINET_set);
  SWIG_addvarlink(globals, "TickRuleType_FIXED_CABINET", Swig_var_TickRuleType_FIXED_CABINET_get, Swig_var_TickRuleType_FIXED_CABINET_set);
  SWIG_addvarlink(globals, "TickRuleType_TRADED_AS_SPREAD", Swig_var_TickRuleType_TRADED_AS_SPREAD_get, Swig_var_TickRuleType_TRADED_AS_SPREAD_set);
  SWIG_addvarlink(globals, "MaturityMonthYearIncrementUnits_MONTHS", Swig_var_MaturityMonthYearIncrementUnits_MONTHS_get, Swig_var_MaturityMonthYearIncrementUnits_MONTHS_set);
  SWIG_addvarlink(globals, "MaturityMonthYearIncrementUnits_DAYS", Swig_var_MaturityMonthYearIncrementUnits_DAYS_get, Swig_var_MaturityMonthYearIncrementUnits_DAYS_set);
  SWIG_addvarlink(globals, "MaturityMonthYearIncrementUnits_WEEKS", Swig_var_MaturityMonthYearIncrementUnits_WEEKS_get, Swig_var_MaturityMonthYearIncrementUnits_WEEKS_set);
  SWIG_addvarlink(globals, "MaturityMonthYearIncrementUnits_YEARS", Swig_var_MaturityMonthYearIncrementUnits_YEARS_get, Swig_var_MaturityMonthYearIncrementUnits_YEARS_set);
  SWIG_addvarlink(globals, "MaturityMonthYearFormat_YEAR_MONTH_ONLY", Swig_var_MaturityMonthYearFormat_YEAR_MONTH_ONLY_get, Swig_var_MaturityMonthYearFormat_YEAR_MONTH_ONLY_set);
  SWIG_addvarlink(globals, "MaturityMonthYearFormat_YEAR_MONTH_DAY", Swig_var_MaturityMonthYearFormat_YEAR_MONTH_DAY_get, Swig_var_MaturityMonthYearFormat_YEAR_MONTH_DAY_set);
  SWIG_addvarlink(globals, "MaturityMonthYearFormat_YEAR_MONTH_WEEK", Swig_var_MaturityMonthYearFormat_YEAR_MONTH_WEEK_get, Swig_var_MaturityMonthYearFormat_YEAR_MONTH_WEEK_set);
  SWIG_addvarlink(globals, "PriceLimitType_PRICE", Swig_var_PriceLimitType_PRICE_get, Swig_var_PriceLimitType_PRICE_set);
  SWIG_addvarlink(globals, "PriceLimitType_TICKS", Swig_var_PriceLimitType_TICKS_get, Swig_var_PriceLimitType_TICKS_set);
  SWIG_addvarlink(globals, "PriceLimitType_PERCENTAGE", Swig_var_PriceLimitType_PERCENTAGE_get, Swig_var_PriceLimitType_PERCENTAGE_set);
  SWIG_addvarlink(globals, "ListUpdateAction_ADD", Swig_var_ListUpdateAction_ADD_get, Swig_var_ListUpdateAction_ADD_set);
  SWIG_addvarlink(globals, "ListUpdateAction_DELETE", Swig_var_ListUpdateAction_DELETE_get, Swig_var_ListUpdateAction_DELETE_set);
  SWIG_addvarlink(globals, "ListUpdateAction_MODIFY", Swig_var_ListUpdateAction_MODIFY_get, Swig_var_ListUpdateAction_MODIFY_set);
  SWIG_addvarlink(globals, "ListUpdateAction_SNAPSHOT", Swig_var_ListUpdateAction_SNAPSHOT_get, Swig_var_ListUpdateAction_SNAPSHOT_set);
  SWIG_addvarlink(globals, "MarketUpdateAction_ADD", Swig_var_MarketUpdateAction_ADD_get, Swig_var_MarketUpdateAction_ADD_set);
  SWIG_addvarlink(globals, "MarketUpdateAction_DELETE", Swig_var_MarketUpdateAction_DELETE_get, Swig_var_MarketUpdateAction_DELETE_set);
  SWIG_addvarlink(globals, "MarketUpdateAction_MODIFY", Swig_var_MarketUpdateAction_MODIFY_get, Swig_var_MarketUpdateAction_MODIFY_set);
  SWIG_addvarlink(globals, "TradSesEvent_TRADING_RESUMES", Swig_var_TradSesEvent_TRADING_RESUMES_get, Swig_var_TradSesEvent_TRADING_RESUMES_set);
  SWIG_addvarlink(globals, "TradSesEvent_CHANGE_OF_TRADING_SESSION", Swig_var_TradSesEvent_CHANGE_OF_TRADING_SESSION_get, Swig_var_TradSesEvent_CHANGE_OF_TRADING_SESSION_set);
  SWIG_addvarlink(globals, "TradSesEvent_CHANGE_OF_TRADING_SUBSESSION", Swig_var_TradSesEvent_CHANGE_OF_TRADING_SUBSESSION_get, Swig_var_TradSesEvent_CHANGE_OF_TRADING_SUBSESSION_set);
  SWIG_addvarlink(globals, "TradSesEvent_CHANGE_OF_TRADING_STATUS", Swig_var_TradSesEvent_CHANGE_OF_TRADING_STATUS_get, Swig_var_TradSesEvent_CHANGE_OF_TRADING_STATUS_set);
  SWIG_addvarlink(globals, "MassActionType_SUSPEND_ORDERS", Swig_var_MassActionType_SUSPEND_ORDERS_get, Swig_var_MassActionType_SUSPEND_ORDERS_set);
  SWIG_addvarlink(globals, "MassActionType_RELEASE_ORDERS_FROM_SUSPENSION", Swig_var_MassActionType_RELEASE_ORDERS_FROM_SUSPENSION_get, Swig_var_MassActionType_RELEASE_ORDERS_FROM_SUSPENSION_set);
  SWIG_addvarlink(globals, "MassActionType_CANCEL_ORDERS", Swig_var_MassActionType_CANCEL_ORDERS_get, Swig_var_MassActionType_CANCEL_ORDERS_set);
  SWIG_addvarlink(globals, "MassActionScope_ALL_ORDERS_FOR_A_SECURITY", Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_set);
  SWIG_addvarlink(globals, "MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY", Swig_var_MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "MassActionScope_ALL_ORDERS_FOR_A_PRODUCT", Swig_var_MassActionScope_ALL_ORDERS_FOR_A_PRODUCT_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_PRODUCT_set);
  SWIG_addvarlink(globals, "MassActionScope_ALL_ORDERS_FOR_ACFI_CODE", Swig_var_MassActionScope_ALL_ORDERS_FOR_ACFI_CODE_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_ACFI_CODE_set);
  SWIG_addvarlink(globals, "MassActionScope_ALL_ORDERS_FOR_A_SECURITY_TYPE", Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_TYPE_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_TYPE_set);
  SWIG_addvarlink(globals, "MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION", Swig_var_MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION_set);
  SWIG_addvarlink(globals, "MassActionScope_ALL_ORDERS", Swig_var_MassActionScope_ALL_ORDERS_get, Swig_var_MassActionScope_ALL_ORDERS_set);
  SWIG_addvarlink(globals, "MassActionScope_ALL_ORDERS_FOR_A_MARKET", Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_set);
  SWIG_addvarlink(globals, "MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT", Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT_set);
  SWIG_addvarlink(globals, "MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP", Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP_set);
  SWIG_addvarlink(globals, "MassActionScope_CANCEL_FOR_SECURITY_ISSUER", Swig_var_MassActionScope_CANCEL_FOR_SECURITY_ISSUER_get, Swig_var_MassActionScope_CANCEL_FOR_SECURITY_ISSUER_set);
  SWIG_addvarlink(globals, "MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY", Swig_var_MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "MassActionResponse_REJECTED", Swig_var_MassActionResponse_REJECTED_get, Swig_var_MassActionResponse_REJECTED_set);
  SWIG_addvarlink(globals, "MassActionResponse_ACCEPTED", Swig_var_MassActionResponse_ACCEPTED_get, Swig_var_MassActionResponse_ACCEPTED_set);
  SWIG_addvarlink(globals, "MassActionResponse_COMPLETED", Swig_var_MassActionResponse_COMPLETED_get, Swig_var_MassActionResponse_COMPLETED_set);
  SWIG_addvarlink(globals, "MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED", Swig_var_MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED_get, Swig_var_MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY", Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_set);
  SWIG_addvarlink(globals, "MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY", Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT", Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT_set);
  SWIG_addvarlink(globals, "MassActionRejectReason_INVALID_OR_UNKNOWN_CFI_CODE", Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_CFI_CODE_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_CFI_CODE_set);
  SWIG_addvarlink(globals, "MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE", Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_set);
  SWIG_addvarlink(globals, "MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION", Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_set);
  SWIG_addvarlink(globals, "MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET", Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_set);
  SWIG_addvarlink(globals, "MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT", Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT_set);
  SWIG_addvarlink(globals, "MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP", Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_set);
  SWIG_addvarlink(globals, "MassActionRejectReason_OTHER", Swig_var_MassActionRejectReason_OTHER_get, Swig_var_MassActionRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER", Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set);
  SWIG_addvarlink(globals, "MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY", Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(globals, "MultilegModel_PREDEFINED_MULTILEG_SECURITY", Swig_var_MultilegModel_PREDEFINED_MULTILEG_SECURITY_get, Swig_var_MultilegModel_PREDEFINED_MULTILEG_SECURITY_set);
  SWIG_addvarlink(globals, "MultilegModel_USER_DEFINED_MULTILEG_SECURITY", Swig_var_MultilegModel_USER_DEFINED_MULTILEG_SECURITY_get, Swig_var_MultilegModel_USER_DEFINED_MULTILEG_SECURITY_set);
  SWIG_addvarlink(globals, "MultilegModel_USER_DEFINED", Swig_var_MultilegModel_USER_DEFINED_get, Swig_var_MultilegModel_USER_DEFINED_set);
  SWIG_addvarlink(globals, "MultilegPriceMethod_NET_PRICE", Swig_var_MultilegPriceMethod_NET_PRICE_get, Swig_var_MultilegPriceMethod_NET_PRICE_set);
  SWIG_addvarlink(globals, "MultilegPriceMethod_REVERSED_NET_PRICE", Swig_var_MultilegPriceMethod_REVERSED_NET_PRICE_get, Swig_var_MultilegPriceMethod_REVERSED_NET_PRICE_set);
  SWIG_addvarlink(globals, "MultilegPriceMethod_YIELD_DIFFERENCE", Swig_var_MultilegPriceMethod_YIELD_DIFFERENCE_get, Swig_var_MultilegPriceMethod_YIELD_DIFFERENCE_set);
  SWIG_addvarlink(globals, "MultilegPriceMethod_INDIVIDUAL", Swig_var_MultilegPriceMethod_INDIVIDUAL_get, Swig_var_MultilegPriceMethod_INDIVIDUAL_set);
  SWIG_addvarlink(globals, "MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE", Swig_var_MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE_get, Swig_var_MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE_set);
  SWIG_addvarlink(globals, "MultilegPriceMethod_MULTIPLIED_PRICE", Swig_var_MultilegPriceMethod_MULTIPLIED_PRICE_get, Swig_var_MultilegPriceMethod_MULTIPLIED_PRICE_set);
  SWIG_addvarlink(globals, "ContingencyType_ONE_CANCELS_THE_OTHER", Swig_var_ContingencyType_ONE_CANCELS_THE_OTHER_get, Swig_var_ContingencyType_ONE_CANCELS_THE_OTHER_set);
  SWIG_addvarlink(globals, "ContingencyType_ONE_TRIGGERS_THE_OTHER", Swig_var_ContingencyType_ONE_TRIGGERS_THE_OTHER_get, Swig_var_ContingencyType_ONE_TRIGGERS_THE_OTHER_set);
  SWIG_addvarlink(globals, "ContingencyType_ONE_UPDATES_THE_OTHER_ABSOLUTE", Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_ABSOLUTE_get, Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_ABSOLUTE_set);
  SWIG_addvarlink(globals, "ContingencyType_ONE_UPDATES_THE_OTHER_PROPORTIONAL", Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_PROPORTIONAL_get, Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_PROPORTIONAL_set);
  SWIG_addvarlink(globals, "ContingencyType_BID_AND_OFFER", Swig_var_ContingencyType_BID_AND_OFFER_get, Swig_var_ContingencyType_BID_AND_OFFER_set);
  SWIG_addvarlink(globals, "ContingencyType_BID_AND_OFFER_OCO", Swig_var_ContingencyType_BID_AND_OFFER_OCO_get, Swig_var_ContingencyType_BID_AND_OFFER_OCO_set);
  SWIG_addvarlink(globals, "ListRejectReason_BROKER_CREDIT", Swig_var_ListRejectReason_BROKER_CREDIT_get, Swig_var_ListRejectReason_BROKER_CREDIT_set);
  SWIG_addvarlink(globals, "ListRejectReason_EXCHANGE_CLOSED", Swig_var_ListRejectReason_EXCHANGE_CLOSED_get, Swig_var_ListRejectReason_EXCHANGE_CLOSED_set);
  SWIG_addvarlink(globals, "ListRejectReason_TOO_LATE_TO_ENTER", Swig_var_ListRejectReason_TOO_LATE_TO_ENTER_get, Swig_var_ListRejectReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(globals, "ListRejectReason_UNKNOWN_ORDER", Swig_var_ListRejectReason_UNKNOWN_ORDER_get, Swig_var_ListRejectReason_UNKNOWN_ORDER_set);
  SWIG_addvarlink(globals, "ListRejectReason_DUPLICATE_ORDER", Swig_var_ListRejectReason_DUPLICATE_ORDER_get, Swig_var_ListRejectReason_DUPLICATE_ORDER_set);
  SWIG_addvarlink(globals, "ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC", Swig_var_ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get, Swig_var_ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC_set);
  SWIG_addvarlink(globals, "ListRejectReason_OTHER", Swig_var_ListRejectReason_OTHER_get, Swig_var_ListRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "TradePublishIndicator_DO_NOT_PUBLISH_TRADE", Swig_var_TradePublishIndicator_DO_NOT_PUBLISH_TRADE_get, Swig_var_TradePublishIndicator_DO_NOT_PUBLISH_TRADE_set);
  SWIG_addvarlink(globals, "TradePublishIndicator_PUBLISH_TRADE", Swig_var_TradePublishIndicator_PUBLISH_TRADE_get, Swig_var_TradePublishIndicator_PUBLISH_TRADE_set);
  SWIG_addvarlink(globals, "TradePublishIndicator_DEFERRED_PUBLICATION", Swig_var_TradePublishIndicator_DEFERRED_PUBLICATION_get, Swig_var_TradePublishIndicator_DEFERRED_PUBLICATION_set);
  SWIG_addvarlink(globals, "TradePublishIndicator_PUBLISHED", Swig_var_TradePublishIndicator_PUBLISHED_get, Swig_var_TradePublishIndicator_PUBLISHED_set);
  SWIG_addvarlink(globals, "ApplReqType_RETRANSMISSION", Swig_var_ApplReqType_RETRANSMISSION_get, Swig_var_ApplReqType_RETRANSMISSION_set);
  SWIG_addvarlink(globals, "ApplReqType_SUBSCRIPTION", Swig_var_ApplReqType_SUBSCRIPTION_get, Swig_var_ApplReqType_SUBSCRIPTION_set);
  SWIG_addvarlink(globals, "ApplReqType_REQUEST_LAST_SEQ_NUM", Swig_var_ApplReqType_REQUEST_LAST_SEQ_NUM_get, Swig_var_ApplReqType_REQUEST_LAST_SEQ_NUM_set);
  SWIG_addvarlink(globals, "ApplReqType_REQUEST_APPLICATIONS", Swig_var_ApplReqType_REQUEST_APPLICATIONS_get, Swig_var_ApplReqType_REQUEST_APPLICATIONS_set);
  SWIG_addvarlink(globals, "ApplReqType_UNSUBSCRIBE", Swig_var_ApplReqType_UNSUBSCRIBE_get, Swig_var_ApplReqType_UNSUBSCRIBE_set);
  SWIG_addvarlink(globals, "ApplReqType_CANCEL_RETRANSMISSION", Swig_var_ApplReqType_CANCEL_RETRANSMISSION_get, Swig_var_ApplReqType_CANCEL_RETRANSMISSION_set);
  SWIG_addvarlink(globals, "ApplReqType_CANCEL_RETRANSMISSION_UNSUBSCRIBE", Swig_var_ApplReqType_CANCEL_RETRANSMISSION_UNSUBSCRIBE_get, Swig_var_ApplReqType_CANCEL_RETRANSMISSION_UNSUBSCRIBE_set);
  SWIG_addvarlink(globals, "ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED", Swig_var_ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED_get, Swig_var_ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED_set);
  SWIG_addvarlink(globals, "ApplResponseType_APPLICATION_DOES_NOT_EXIST", Swig_var_ApplResponseType_APPLICATION_DOES_NOT_EXIST_get, Swig_var_ApplResponseType_APPLICATION_DOES_NOT_EXIST_set);
  SWIG_addvarlink(globals, "ApplResponseType_MESSAGES_NOT_AVAILABLE", Swig_var_ApplResponseType_MESSAGES_NOT_AVAILABLE_get, Swig_var_ApplResponseType_MESSAGES_NOT_AVAILABLE_set);
  SWIG_addvarlink(globals, "ApplResponseError_APPLICATION_DOES_NOT_EXIST", Swig_var_ApplResponseError_APPLICATION_DOES_NOT_EXIST_get, Swig_var_ApplResponseError_APPLICATION_DOES_NOT_EXIST_set);
  SWIG_addvarlink(globals, "ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE", Swig_var_ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE_get, Swig_var_ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE_set);
  SWIG_addvarlink(globals, "ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION", Swig_var_ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION_get, Swig_var_ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION_set);
  SWIG_addvarlink(globals, "ApplReportType_APPL_SEQ_NUM_RESET", Swig_var_ApplReportType_APPL_SEQ_NUM_RESET_get, Swig_var_ApplReportType_APPL_SEQ_NUM_RESET_set);
  SWIG_addvarlink(globals, "ApplReportType_LAST_MESSAGE_SENT", Swig_var_ApplReportType_LAST_MESSAGE_SENT_get, Swig_var_ApplReportType_LAST_MESSAGE_SENT_set);
  SWIG_addvarlink(globals, "ApplReportType_APPLICATION_ALIVE", Swig_var_ApplReportType_APPLICATION_ALIVE_get, Swig_var_ApplReportType_APPLICATION_ALIVE_set);
  SWIG_addvarlink(globals, "ApplReportType_RESEND_COMPLETE", Swig_var_ApplReportType_RESEND_COMPLETE_get, Swig_var_ApplReportType_RESEND_COMPLETE_set);
  SWIG_addvarlink(globals, "HaltReasonInt_NEWS_DISSEMINATION", Swig_var_HaltReasonInt_NEWS_DISSEMINATION_get, Swig_var_HaltReasonInt_NEWS_DISSEMINATION_set);
  SWIG_addvarlink(globals, "HaltReasonInt_ORDER_INFLUX", Swig_var_HaltReasonInt_ORDER_INFLUX_get, Swig_var_HaltReasonInt_ORDER_INFLUX_set);
  SWIG_addvarlink(globals, "HaltReasonInt_ORDER_IMBALANCE", Swig_var_HaltReasonInt_ORDER_IMBALANCE_get, Swig_var_HaltReasonInt_ORDER_IMBALANCE_set);
  SWIG_addvarlink(globals, "HaltReasonInt_ADDITIONAL_INFORMATION", Swig_var_HaltReasonInt_ADDITIONAL_INFORMATION_get, Swig_var_HaltReasonInt_ADDITIONAL_INFORMATION_set);
  SWIG_addvarlink(globals, "HaltReasonInt_NEWS_PENDING", Swig_var_HaltReasonInt_NEWS_PENDING_get, Swig_var_HaltReasonInt_NEWS_PENDING_set);
  SWIG_addvarlink(globals, "HaltReasonInt_EQUIPMENT_CHANGEOVER", Swig_var_HaltReasonInt_EQUIPMENT_CHANGEOVER_get, Swig_var_HaltReasonInt_EQUIPMENT_CHANGEOVER_set);
  SWIG_addvarlink(globals, "ValuationMethod_PREMIUM_STYLE", Swig_var_ValuationMethod_PREMIUM_STYLE_get, Swig_var_ValuationMethod_PREMIUM_STYLE_set);
  SWIG_addvarlink(globals, "ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET", Swig_var_ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get, Swig_var_ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_set);
  SWIG_addvarlink(globals, "ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT", Swig_var_ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get, Swig_var_ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_set);
  SWIG_addvarlink(globals, "ValuationMethod_CDS_STYLE_COLLATERALIZATION", Swig_var_ValuationMethod_CDS_STYLE_COLLATERALIZATION_get, Swig_var_ValuationMethod_CDS_STYLE_COLLATERALIZATION_set);
  SWIG_addvarlink(globals, "ValuationMethod_CDS_IN_DELIVERY_USE_RECOVERY_RATE_TO_CALCULATE", Swig_var_ValuationMethod_CDS_IN_DELIVERY_USE_RECOVERY_RATE_TO_CALCULATE_get, Swig_var_ValuationMethod_CDS_IN_DELIVERY_USE_RECOVERY_RATE_TO_CALCULATE_set);
  SWIG_addvarlink(globals, "OrderDelayUnit_SECONDS", Swig_var_OrderDelayUnit_SECONDS_get, Swig_var_OrderDelayUnit_SECONDS_set);
  SWIG_addvarlink(globals, "OrderDelayUnit_TENTHS_OF_A_SECOND", Swig_var_OrderDelayUnit_TENTHS_OF_A_SECOND_get, Swig_var_OrderDelayUnit_TENTHS_OF_A_SECOND_set);
  SWIG_addvarlink(globals, "OrderDelayUnit_HUNDREDTHS_OF_A_SECOND", Swig_var_OrderDelayUnit_HUNDREDTHS_OF_A_SECOND_get, Swig_var_OrderDelayUnit_HUNDREDTHS_OF_A_SECOND_set);
  SWIG_addvarlink(globals, "OrderDelayUnit_MILLISECONDS", Swig_var_OrderDelayUnit_MILLISECONDS_get, Swig_var_OrderDelayUnit_MILLISECONDS_set);
  SWIG_addvarlink(globals, "OrderDelayUnit_MICROSECONDS", Swig_var_OrderDelayUnit_MICROSECONDS_get, Swig_var_OrderDelayUnit_MICROSECONDS_set);
  SWIG_addvarlink(globals, "OrderDelayUnit_NANOSECONDS", Swig_var_OrderDelayUnit_NANOSECONDS_get, Swig_var_OrderDelayUnit_NANOSECONDS_set);
  SWIG_addvarlink(globals, "OrderDelayUnit_MINUTES", Swig_var_OrderDelayUnit_MINUTES_get, Swig_var_OrderDelayUnit_MINUTES_set);
  SWIG_addvarlink(globals, "OrderDelayUnit_HOURS", Swig_var_OrderDelayUnit_HOURS_get, Swig_var_OrderDelayUnit_HOURS_set);
  SWIG_addvarlink(globals, "OrderDelayUnit_DAYS", Swig_var_OrderDelayUnit_DAYS_get, Swig_var_OrderDelayUnit_DAYS_set);
  SWIG_addvarlink(globals, "OrderDelayUnit_WEEKS", Swig_var_OrderDelayUnit_WEEKS_get, Swig_var_OrderDelayUnit_WEEKS_set);
  SWIG_addvarlink(globals, "OrderDelayUnit_MONTHS", Swig_var_OrderDelayUnit_MONTHS_get, Swig_var_OrderDelayUnit_MONTHS_set);
  SWIG_addvarlink(globals, "OrderDelayUnit_YEARS", Swig_var_OrderDelayUnit_YEARS_get, Swig_var_OrderDelayUnit_YEARS_set);
  SWIG_addvarlink(globals, "VenueType_ELECTRONIC", Swig_var_VenueType_ELECTRONIC_get, Swig_var_VenueType_ELECTRONIC_set);
  SWIG_addvarlink(globals, "VenueType_PIT", Swig_var_VenueType_PIT_get, Swig_var_VenueType_PIT_set);
  SWIG_addvarlink(globals, "VenueType_EX_PIT", Swig_var_VenueType_EX_PIT_get, Swig_var_VenueType_EX_PIT_set);
  SWIG_addvarlink(globals, "VenueType_CLEARING_HOUSE", Swig_var_VenueType_CLEARING_HOUSE_get, Swig_var_VenueType_CLEARING_HOUSE_set);
  SWIG_addvarlink(globals, "VenueType_REGISTERED_MARKET", Swig_var_VenueType_REGISTERED_MARKET_get, Swig_var_VenueType_REGISTERED_MARKET_set);
  SWIG_addvarlink(globals, "VenueType_OFF_MARKET", Swig_var_VenueType_OFF_MARKET_get, Swig_var_VenueType_OFF_MARKET_set);
  SWIG_addvarlink(globals, "VenueType_CENTRAL_LIMIT_ORDER_BOOK", Swig_var_VenueType_CENTRAL_LIMIT_ORDER_BOOK_get, Swig_var_VenueType_CENTRAL_LIMIT_ORDER_BOOK_set);
  SWIG_addvarlink(globals, "VenueType_QUOTE_DRIVEN_MARKET", Swig_var_VenueType_QUOTE_DRIVEN_MARKET_get, Swig_var_VenueType_QUOTE_DRIVEN_MARKET_set);
  SWIG_addvarlink(globals, "VenueType_DARK_ORDER_BOOK", Swig_var_VenueType_DARK_ORDER_BOOK_get, Swig_var_VenueType_DARK_ORDER_BOOK_set);
  SWIG_addvarlink(globals, "VenueType_AUCTION_DRIVEN_MARKET", Swig_var_VenueType_AUCTION_DRIVEN_MARKET_get, Swig_var_VenueType_AUCTION_DRIVEN_MARKET_set);
  SWIG_addvarlink(globals, "VenueType_QUOTE_NEGOTIATION", Swig_var_VenueType_QUOTE_NEGOTIATION_get, Swig_var_VenueType_QUOTE_NEGOTIATION_set);
  SWIG_addvarlink(globals, "VenueType_VOICE_NEGOTIATION", Swig_var_VenueType_VOICE_NEGOTIATION_get, Swig_var_VenueType_VOICE_NEGOTIATION_set);
  SWIG_addvarlink(globals, "VenueType_HYBRID_MARKET", Swig_var_VenueType_HYBRID_MARKET_get, Swig_var_VenueType_HYBRID_MARKET_set);
  SWIG_addvarlink(globals, "VenueType_OTHER_MARKET", Swig_var_VenueType_OTHER_MARKET_get, Swig_var_VenueType_OTHER_MARKET_set);
  SWIG_addvarlink(globals, "RefOrdIDReason_GTC_FROM_PREVIOUS_DAY", Swig_var_RefOrdIDReason_GTC_FROM_PREVIOUS_DAY_get, Swig_var_RefOrdIDReason_GTC_FROM_PREVIOUS_DAY_set);
  SWIG_addvarlink(globals, "RefOrdIDReason_PARTIAL_FILL_REMAINING", Swig_var_RefOrdIDReason_PARTIAL_FILL_REMAINING_get, Swig_var_RefOrdIDReason_PARTIAL_FILL_REMAINING_set);
  SWIG_addvarlink(globals, "RefOrdIDReason_ORDER_CHANGED", Swig_var_RefOrdIDReason_ORDER_CHANGED_get, Swig_var_RefOrdIDReason_ORDER_CHANGED_set);
  SWIG_addvarlink(globals, "OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT", Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get, Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_set);
  SWIG_addvarlink(globals, "OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT", Swig_var_OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get, Swig_var_OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_set);
  SWIG_addvarlink(globals, "OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER", Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get, Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_set);
  SWIG_addvarlink(globals, "OrigCustOrderCapacity_ALL_OTHER", Swig_var_OrigCustOrderCapacity_ALL_OTHER_get, Swig_var_OrigCustOrderCapacity_ALL_OTHER_set);
  SWIG_addvarlink(globals, "ModelType_UTILITY_PROVIDED_STANDARD_MODEL", Swig_var_ModelType_UTILITY_PROVIDED_STANDARD_MODEL_get, Swig_var_ModelType_UTILITY_PROVIDED_STANDARD_MODEL_set);
  SWIG_addvarlink(globals, "ModelType_PROPRIETARY_MODEL", Swig_var_ModelType_PROPRIETARY_MODEL_get, Swig_var_ModelType_PROPRIETARY_MODEL_set);
  SWIG_addvarlink(globals, "ContractMultiplierUnit_SHARES", Swig_var_ContractMultiplierUnit_SHARES_get, Swig_var_ContractMultiplierUnit_SHARES_set);
  SWIG_addvarlink(globals, "ContractMultiplierUnit_HOURS", Swig_var_ContractMultiplierUnit_HOURS_get, Swig_var_ContractMultiplierUnit_HOURS_set);
  SWIG_addvarlink(globals, "ContractMultiplierUnit_DAYS", Swig_var_ContractMultiplierUnit_DAYS_get, Swig_var_ContractMultiplierUnit_DAYS_set);
  SWIG_addvarlink(globals, "FlowScheduleType_NERC_EASTERN_OFF_PEAK", Swig_var_FlowScheduleType_NERC_EASTERN_OFF_PEAK_get, Swig_var_FlowScheduleType_NERC_EASTERN_OFF_PEAK_set);
  SWIG_addvarlink(globals, "FlowScheduleType_NERC_WESTERN_OFF_PEAK", Swig_var_FlowScheduleType_NERC_WESTERN_OFF_PEAK_get, Swig_var_FlowScheduleType_NERC_WESTERN_OFF_PEAK_set);
  SWIG_addvarlink(globals, "FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH", Swig_var_FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH_get, Swig_var_FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH_set);
  SWIG_addvarlink(globals, "FlowScheduleType_NERC_EASTERN_PEAK", Swig_var_FlowScheduleType_NERC_EASTERN_PEAK_get, Swig_var_FlowScheduleType_NERC_EASTERN_PEAK_set);
  SWIG_addvarlink(globals, "FlowScheduleType_NERC_WESTERN_PEAK", Swig_var_FlowScheduleType_NERC_WESTERN_PEAK_get, Swig_var_FlowScheduleType_NERC_WESTERN_PEAK_set);
  SWIG_addvarlink(globals, "FlowScheduleType_ALL_TIMES", Swig_var_FlowScheduleType_ALL_TIMES_get, Swig_var_FlowScheduleType_ALL_TIMES_set);
  SWIG_addvarlink(globals, "FlowScheduleType_ON_PEAK", Swig_var_FlowScheduleType_ON_PEAK_get, Swig_var_FlowScheduleType_ON_PEAK_set);
  SWIG_addvarlink(globals, "FlowScheduleType_OFF_PEAK", Swig_var_FlowScheduleType_OFF_PEAK_get, Swig_var_FlowScheduleType_OFF_PEAK_set);
  SWIG_addvarlink(globals, "FlowScheduleType_BASE", Swig_var_FlowScheduleType_BASE_get, Swig_var_FlowScheduleType_BASE_set);
  SWIG_addvarlink(globals, "FlowScheduleType_BLOCK", Swig_var_FlowScheduleType_BLOCK_get, Swig_var_FlowScheduleType_BLOCK_set);
  SWIG_addvarlink(globals, "FlowScheduleType_OTHER", Swig_var_FlowScheduleType_OTHER_get, Swig_var_FlowScheduleType_OTHER_set);
  SWIG_addvarlink(globals, "RateSource_BLOOMBERG", Swig_var_RateSource_BLOOMBERG_get, Swig_var_RateSource_BLOOMBERG_set);
  SWIG_addvarlink(globals, "RateSource_REUTERS", Swig_var_RateSource_REUTERS_get, Swig_var_RateSource_REUTERS_set);
  SWIG_addvarlink(globals, "RateSource_TELERATE", Swig_var_RateSource_TELERATE_get, Swig_var_RateSource_TELERATE_set);
  SWIG_addvarlink(globals, "RateSource_ISDA_RATE_OPTION", Swig_var_RateSource_ISDA_RATE_OPTION_get, Swig_var_RateSource_ISDA_RATE_OPTION_set);
  SWIG_addvarlink(globals, "RateSource_OTHER", Swig_var_RateSource_OTHER_get, Swig_var_RateSource_OTHER_set);
  SWIG_addvarlink(globals, "RateSourceType_PRIMARY", Swig_var_RateSourceType_PRIMARY_get, Swig_var_RateSourceType_PRIMARY_set);
  SWIG_addvarlink(globals, "RateSourceType_SECONDARY", Swig_var_RateSourceType_SECONDARY_get, Swig_var_RateSourceType_SECONDARY_set);
  SWIG_addvarlink(globals, "RestructuringType_FULL_RESTRUCTURING", Swig_var_RestructuringType_FULL_RESTRUCTURING_get, Swig_var_RestructuringType_FULL_RESTRUCTURING_set);
  SWIG_addvarlink(globals, "RestructuringType_MODIFIED_RESTRUCTURING", Swig_var_RestructuringType_MODIFIED_RESTRUCTURING_get, Swig_var_RestructuringType_MODIFIED_RESTRUCTURING_set);
  SWIG_addvarlink(globals, "RestructuringType_MODIFIED_MOD_RESTRUCTURING", Swig_var_RestructuringType_MODIFIED_MOD_RESTRUCTURING_get, Swig_var_RestructuringType_MODIFIED_MOD_RESTRUCTURING_set);
  SWIG_addvarlink(globals, "RestructuringType_NO_RESTRUCTURING_SPECIFIED", Swig_var_RestructuringType_NO_RESTRUCTURING_SPECIFIED_get, Swig_var_RestructuringType_NO_RESTRUCTURING_SPECIFIED_set);
  SWIG_addvarlink(globals, "Seniority_SENIOR_SECURED", Swig_var_Seniority_SENIOR_SECURED_get, Swig_var_Seniority_SENIOR_SECURED_set);
  SWIG_addvarlink(globals, "Seniority_SENIOR", Swig_var_Seniority_SENIOR_get, Swig_var_Seniority_SENIOR_set);
  SWIG_addvarlink(globals, "Seniority_SUBORDINATED", Swig_var_Seniority_SUBORDINATED_get, Swig_var_Seniority_SUBORDINATED_set);
  SWIG_addvarlink(globals, "Seniority_JUNIOR", Swig_var_Seniority_JUNIOR_get, Swig_var_Seniority_JUNIOR_set);
  SWIG_addvarlink(globals, "Seniority_MEZZANINE", Swig_var_Seniority_MEZZANINE_get, Swig_var_Seniority_MEZZANINE_set);
  SWIG_addvarlink(globals, "Seniority_SENIOR_NON_PREFERRED", Swig_var_Seniority_SENIOR_NON_PREFERRED_get, Swig_var_Seniority_SENIOR_NON_PREFERRED_set);
  SWIG_addvarlink(globals, "SecurityListType_INDUSTRY_CLASSIFICATION", Swig_var_SecurityListType_INDUSTRY_CLASSIFICATION_get, Swig_var_SecurityListType_INDUSTRY_CLASSIFICATION_set);
  SWIG_addvarlink(globals, "SecurityListType_TRADING_LIST", Swig_var_SecurityListType_TRADING_LIST_get, Swig_var_SecurityListType_TRADING_LIST_set);
  SWIG_addvarlink(globals, "SecurityListType_MARKET", Swig_var_SecurityListType_MARKET_get, Swig_var_SecurityListType_MARKET_set);
  SWIG_addvarlink(globals, "SecurityListType_NEWSPAPER_LIST", Swig_var_SecurityListType_NEWSPAPER_LIST_get, Swig_var_SecurityListType_NEWSPAPER_LIST_set);
  SWIG_addvarlink(globals, "SecurityListTypeSource_ICB", Swig_var_SecurityListTypeSource_ICB_get, Swig_var_SecurityListTypeSource_ICB_set);
  SWIG_addvarlink(globals, "SecurityListTypeSource_NAICS", Swig_var_SecurityListTypeSource_NAICS_get, Swig_var_SecurityListTypeSource_NAICS_set);
  SWIG_addvarlink(globals, "SecurityListTypeSource_GICS", Swig_var_SecurityListTypeSource_GICS_get, Swig_var_SecurityListTypeSource_GICS_set);
  SWIG_addvarlink(globals, "NewsCategory_COMPANY_NEWS", Swig_var_NewsCategory_COMPANY_NEWS_get, Swig_var_NewsCategory_COMPANY_NEWS_set);
  SWIG_addvarlink(globals, "NewsCategory_MARKETPLACE_NEWS", Swig_var_NewsCategory_MARKETPLACE_NEWS_get, Swig_var_NewsCategory_MARKETPLACE_NEWS_set);
  SWIG_addvarlink(globals, "NewsCategory_FINANCIAL_MARKET_NEWS", Swig_var_NewsCategory_FINANCIAL_MARKET_NEWS_get, Swig_var_NewsCategory_FINANCIAL_MARKET_NEWS_set);
  SWIG_addvarlink(globals, "NewsCategory_TECHNICAL_NEWS", Swig_var_NewsCategory_TECHNICAL_NEWS_get, Swig_var_NewsCategory_TECHNICAL_NEWS_set);
  SWIG_addvarlink(globals, "NewsCategory_OTHER_NEWS", Swig_var_NewsCategory_OTHER_NEWS_get, Swig_var_NewsCategory_OTHER_NEWS_set);
  SWIG_addvarlink(globals, "NewsRefType_REPLACEMENT", Swig_var_NewsRefType_REPLACEMENT_get, Swig_var_NewsRefType_REPLACEMENT_set);
  SWIG_addvarlink(globals, "NewsRefType_OTHER_LANGUAGE", Swig_var_NewsRefType_OTHER_LANGUAGE_get, Swig_var_NewsRefType_OTHER_LANGUAGE_set);
  SWIG_addvarlink(globals, "NewsRefType_COMPLIMENTARY", Swig_var_NewsRefType_COMPLIMENTARY_get, Swig_var_NewsRefType_COMPLIMENTARY_set);
  SWIG_addvarlink(globals, "NewsRefType_WITHDRAWAL", Swig_var_NewsRefType_WITHDRAWAL_get, Swig_var_NewsRefType_WITHDRAWAL_set);
  SWIG_addvarlink(globals, "StrikePriceDeterminationMethod_FIXED_STRIKE", Swig_var_StrikePriceDeterminationMethod_FIXED_STRIKE_get, Swig_var_StrikePriceDeterminationMethod_FIXED_STRIKE_set);
  SWIG_addvarlink(globals, "StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION", Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_get, Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_set);
  SWIG_addvarlink(globals, "StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_ACROSS_LIFE", Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_ACROSS_LIFE_get, Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_ACROSS_LIFE_set);
  SWIG_addvarlink(globals, "StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE", Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE_get, Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE_set);
  SWIG_addvarlink(globals, "StrikePriceBoundaryMethod_LESS_THAN", Swig_var_StrikePriceBoundaryMethod_LESS_THAN_get, Swig_var_StrikePriceBoundaryMethod_LESS_THAN_set);
  SWIG_addvarlink(globals, "StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL", Swig_var_StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_get, Swig_var_StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_set);
  SWIG_addvarlink(globals, "StrikePriceBoundaryMethod_EQUAL", Swig_var_StrikePriceBoundaryMethod_EQUAL_get, Swig_var_StrikePriceBoundaryMethod_EQUAL_set);
  SWIG_addvarlink(globals, "StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL", Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_get, Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_set);
  SWIG_addvarlink(globals, "StrikePriceBoundaryMethod_GREATER_THAN", Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_get, Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_set);
  SWIG_addvarlink(globals, "UnderlyingPriceDeterminationMethod_REGULAR", Swig_var_UnderlyingPriceDeterminationMethod_REGULAR_get, Swig_var_UnderlyingPriceDeterminationMethod_REGULAR_set);
  SWIG_addvarlink(globals, "UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE", Swig_var_UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_get, Swig_var_UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_set);
  SWIG_addvarlink(globals, "UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE", Swig_var_UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_get, Swig_var_UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_set);
  SWIG_addvarlink(globals, "UnderlyingPriceDeterminationMethod_AVERAGE_VALUE", Swig_var_UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_get, Swig_var_UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_set);
  SWIG_addvarlink(globals, "OptPayoutType_VANILLA", Swig_var_OptPayoutType_VANILLA_get, Swig_var_OptPayoutType_VANILLA_set);
  SWIG_addvarlink(globals, "OptPayoutType_CAPPED", Swig_var_OptPayoutType_CAPPED_get, Swig_var_OptPayoutType_CAPPED_set);
  SWIG_addvarlink(globals, "OptPayoutType_BINARY", Swig_var_OptPayoutType_BINARY_get, Swig_var_OptPayoutType_BINARY_set);
  SWIG_addvarlink(globals, "OptPayoutType_ASIAN", Swig_var_OptPayoutType_ASIAN_get, Swig_var_OptPayoutType_ASIAN_set);
  SWIG_addvarlink(globals, "OptPayoutType_BARRIER", Swig_var_OptPayoutType_BARRIER_get, Swig_var_OptPayoutType_BARRIER_set);
  SWIG_addvarlink(globals, "OptPayoutType_DIGITAL_BARRIER", Swig_var_OptPayoutType_DIGITAL_BARRIER_get, Swig_var_OptPayoutType_DIGITAL_BARRIER_set);
  SWIG_addvarlink(globals, "OptPayoutType_LOOKBACK", Swig_var_OptPayoutType_LOOKBACK_get, Swig_var_OptPayoutType_LOOKBACK_set);
  SWIG_addvarlink(globals, "OptPayoutType_OTHER_PATH_DEPENDENT", Swig_var_OptPayoutType_OTHER_PATH_DEPENDENT_get, Swig_var_OptPayoutType_OTHER_PATH_DEPENDENT_set);
  SWIG_addvarlink(globals, "OptPayoutType_OTHER", Swig_var_OptPayoutType_OTHER_get, Swig_var_OptPayoutType_OTHER_set);
  SWIG_addvarlink(globals, "ComplexEventType_CAPPED", Swig_var_ComplexEventType_CAPPED_get, Swig_var_ComplexEventType_CAPPED_set);
  SWIG_addvarlink(globals, "ComplexEventType_TRIGGER", Swig_var_ComplexEventType_TRIGGER_get, Swig_var_ComplexEventType_TRIGGER_set);
  SWIG_addvarlink(globals, "ComplexEventType_KNOCK_IN_UP", Swig_var_ComplexEventType_KNOCK_IN_UP_get, Swig_var_ComplexEventType_KNOCK_IN_UP_set);
  SWIG_addvarlink(globals, "ComplexEventType_KNOCK_IN_DOWN", Swig_var_ComplexEventType_KNOCK_IN_DOWN_get, Swig_var_ComplexEventType_KNOCK_IN_DOWN_set);
  SWIG_addvarlink(globals, "ComplexEventType_KNOCK_OUT_UP", Swig_var_ComplexEventType_KNOCK_OUT_UP_get, Swig_var_ComplexEventType_KNOCK_OUT_UP_set);
  SWIG_addvarlink(globals, "ComplexEventType_KNOCK_OUT_DOWN", Swig_var_ComplexEventType_KNOCK_OUT_DOWN_get, Swig_var_ComplexEventType_KNOCK_OUT_DOWN_set);
  SWIG_addvarlink(globals, "ComplexEventType_UNDERLYING", Swig_var_ComplexEventType_UNDERLYING_get, Swig_var_ComplexEventType_UNDERLYING_set);
  SWIG_addvarlink(globals, "ComplexEventType_RESET_BARRIER", Swig_var_ComplexEventType_RESET_BARRIER_get, Swig_var_ComplexEventType_RESET_BARRIER_set);
  SWIG_addvarlink(globals, "ComplexEventType_ROLLING_BARRIER", Swig_var_ComplexEventType_ROLLING_BARRIER_get, Swig_var_ComplexEventType_ROLLING_BARRIER_set);
  SWIG_addvarlink(globals, "ComplexEventType_ONE_TOUCH", Swig_var_ComplexEventType_ONE_TOUCH_get, Swig_var_ComplexEventType_ONE_TOUCH_set);
  SWIG_addvarlink(globals, "ComplexEventType_NO_TOUCH", Swig_var_ComplexEventType_NO_TOUCH_get, Swig_var_ComplexEventType_NO_TOUCH_set);
  SWIG_addvarlink(globals, "ComplexEventType_DBL_ONE_TOUCH", Swig_var_ComplexEventType_DBL_ONE_TOUCH_get, Swig_var_ComplexEventType_DBL_ONE_TOUCH_set);
  SWIG_addvarlink(globals, "ComplexEventType_DBL_NO_TOUCH", Swig_var_ComplexEventType_DBL_NO_TOUCH_get, Swig_var_ComplexEventType_DBL_NO_TOUCH_set);
  SWIG_addvarlink(globals, "ComplexEventType_FX_COMPOSITE", Swig_var_ComplexEventType_FX_COMPOSITE_get, Swig_var_ComplexEventType_FX_COMPOSITE_set);
  SWIG_addvarlink(globals, "ComplexEventType_FX_QUANTO", Swig_var_ComplexEventType_FX_QUANTO_get, Swig_var_ComplexEventType_FX_QUANTO_set);
  SWIG_addvarlink(globals, "ComplexEventType_FX_CRSS_CCY", Swig_var_ComplexEventType_FX_CRSS_CCY_get, Swig_var_ComplexEventType_FX_CRSS_CCY_set);
  SWIG_addvarlink(globals, "ComplexEventType_STRK_SPREAD", Swig_var_ComplexEventType_STRK_SPREAD_get, Swig_var_ComplexEventType_STRK_SPREAD_set);
  SWIG_addvarlink(globals, "ComplexEventType_CLNDR_SPREAD", Swig_var_ComplexEventType_CLNDR_SPREAD_get, Swig_var_ComplexEventType_CLNDR_SPREAD_set);
  SWIG_addvarlink(globals, "ComplexEventType_PX_OBSVTN", Swig_var_ComplexEventType_PX_OBSVTN_get, Swig_var_ComplexEventType_PX_OBSVTN_set);
  SWIG_addvarlink(globals, "ComplexEventType_PASS_THROUGH", Swig_var_ComplexEventType_PASS_THROUGH_get, Swig_var_ComplexEventType_PASS_THROUGH_set);
  SWIG_addvarlink(globals, "ComplexEventType_STRK_SCHED", Swig_var_ComplexEventType_STRK_SCHED_get, Swig_var_ComplexEventType_STRK_SCHED_set);
  SWIG_addvarlink(globals, "ComplexEventType_EQUITY_VALUATION", Swig_var_ComplexEventType_EQUITY_VALUATION_get, Swig_var_ComplexEventType_EQUITY_VALUATION_set);
  SWIG_addvarlink(globals, "ComplexEventType_DIVIDEND_VALUATION", Swig_var_ComplexEventType_DIVIDEND_VALUATION_get, Swig_var_ComplexEventType_DIVIDEND_VALUATION_set);
  SWIG_addvarlink(globals, "ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEX_EVENT_PRICE", Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEX_EVENT_PRICE_get, Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEX_EVENT_PRICE_set);
  SWIG_addvarlink(globals, "ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEX_EVENT_PRICE", Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEX_EVENT_PRICE_get, Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEX_EVENT_PRICE_set);
  SWIG_addvarlink(globals, "ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEX_EVENT_PRICE", Swig_var_ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEX_EVENT_PRICE_get, Swig_var_ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEX_EVENT_PRICE_set);
  SWIG_addvarlink(globals, "ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEX_EVENT_PRICE", Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEX_EVENT_PRICE_get, Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEX_EVENT_PRICE_set);
  SWIG_addvarlink(globals, "ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEX_EVENT_PRICE", Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEX_EVENT_PRICE_get, Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEX_EVENT_PRICE_set);
  SWIG_addvarlink(globals, "ComplexEventPriceTimeType_EXPIRATION", Swig_var_ComplexEventPriceTimeType_EXPIRATION_get, Swig_var_ComplexEventPriceTimeType_EXPIRATION_set);
  SWIG_addvarlink(globals, "ComplexEventPriceTimeType_IMMEDIATE", Swig_var_ComplexEventPriceTimeType_IMMEDIATE_get, Swig_var_ComplexEventPriceTimeType_IMMEDIATE_set);
  SWIG_addvarlink(globals, "ComplexEventPriceTimeType_SPECIFIED_DATE", Swig_var_ComplexEventPriceTimeType_SPECIFIED_DATE_get, Swig_var_ComplexEventPriceTimeType_SPECIFIED_DATE_set);
  SWIG_addvarlink(globals, "ComplexEventPriceTimeType_CLOSE", Swig_var_ComplexEventPriceTimeType_CLOSE_get, Swig_var_ComplexEventPriceTimeType_CLOSE_set);
  SWIG_addvarlink(globals, "ComplexEventPriceTimeType_OPEN", Swig_var_ComplexEventPriceTimeType_OPEN_get, Swig_var_ComplexEventPriceTimeType_OPEN_set);
  SWIG_addvarlink(globals, "ComplexEventPriceTimeType_OFFICIAL_SETTL_PRICE", Swig_var_ComplexEventPriceTimeType_OFFICIAL_SETTL_PRICE_get, Swig_var_ComplexEventPriceTimeType_OFFICIAL_SETTL_PRICE_set);
  SWIG_addvarlink(globals, "ComplexEventPriceTimeType_DERIVATIVES_CLOSE", Swig_var_ComplexEventPriceTimeType_DERIVATIVES_CLOSE_get, Swig_var_ComplexEventPriceTimeType_DERIVATIVES_CLOSE_set);
  SWIG_addvarlink(globals, "ComplexEventPriceTimeType_AS_SPECIFIED_MASTER_CONFIRMATION", Swig_var_ComplexEventPriceTimeType_AS_SPECIFIED_MASTER_CONFIRMATION_get, Swig_var_ComplexEventPriceTimeType_AS_SPECIFIED_MASTER_CONFIRMATION_set);
  SWIG_addvarlink(globals, "ComplexEventCondition_AND", Swig_var_ComplexEventCondition_AND_get, Swig_var_ComplexEventCondition_AND_set);
  SWIG_addvarlink(globals, "ComplexEventCondition_OR", Swig_var_ComplexEventCondition_OR_get, Swig_var_ComplexEventCondition_OR_set);
  SWIG_addvarlink(globals, "StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER", Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER_get, Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER_set);
  SWIG_addvarlink(globals, "StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER", Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER_get, Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER_set);
  SWIG_addvarlink(globals, "StreamAsgnRejReason_UNKNOWN_CLIENT", Swig_var_StreamAsgnRejReason_UNKNOWN_CLIENT_get, Swig_var_StreamAsgnRejReason_UNKNOWN_CLIENT_set);
  SWIG_addvarlink(globals, "StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE", Swig_var_StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE_get, Swig_var_StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE_set);
  SWIG_addvarlink(globals, "StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR", Swig_var_StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR_get, Swig_var_StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR_set);
  SWIG_addvarlink(globals, "StreamAsgnRejReason_NO_AVAILABLE_STREAM", Swig_var_StreamAsgnRejReason_NO_AVAILABLE_STREAM_get, Swig_var_StreamAsgnRejReason_NO_AVAILABLE_STREAM_set);
  SWIG_addvarlink(globals, "StreamAsgnRejReason_OTHER", Swig_var_StreamAsgnRejReason_OTHER_get, Swig_var_StreamAsgnRejReason_OTHER_set);
  SWIG_addvarlink(globals, "StreamAsgnAckType_ASSIGNMENT_ACCEPTED", Swig_var_StreamAsgnAckType_ASSIGNMENT_ACCEPTED_get, Swig_var_StreamAsgnAckType_ASSIGNMENT_ACCEPTED_set);
  SWIG_addvarlink(globals, "StreamAsgnAckType_ASSIGNMENT_REJECTED", Swig_var_StreamAsgnAckType_ASSIGNMENT_REJECTED_get, Swig_var_StreamAsgnAckType_ASSIGNMENT_REJECTED_set);
  SWIG_addvarlink(globals, "StreamAsgnType_ASSIGNMENT", Swig_var_StreamAsgnType_ASSIGNMENT_get, Swig_var_StreamAsgnType_ASSIGNMENT_set);
  SWIG_addvarlink(globals, "StreamAsgnType_REJECTED", Swig_var_StreamAsgnType_REJECTED_get, Swig_var_StreamAsgnType_REJECTED_set);
  SWIG_addvarlink(globals, "StreamAsgnType_TERMINATE", Swig_var_StreamAsgnType_TERMINATE_get, Swig_var_StreamAsgnType_TERMINATE_set);
  SWIG_addvarlink(globals, "MatchInst_MATCH", Swig_var_MatchInst_MATCH_get, Swig_var_MatchInst_MATCH_set);
  SWIG_addvarlink(globals, "MatchInst_DO_NOT_MATCH", Swig_var_MatchInst_DO_NOT_MATCH_get, Swig_var_MatchInst_DO_NOT_MATCH_set);
  SWIG_addvarlink(globals, "TriggerScope_THIS_ORDER", Swig_var_TriggerScope_THIS_ORDER_get, Swig_var_TriggerScope_THIS_ORDER_set);
  SWIG_addvarlink(globals, "TriggerScope_OTHER_ORDER", Swig_var_TriggerScope_OTHER_ORDER_get, Swig_var_TriggerScope_OTHER_ORDER_set);
  SWIG_addvarlink(globals, "TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY", Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_get, Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_set);
  SWIG_addvarlink(globals, "TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_AND_PRICE", Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_AND_PRICE_get, Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_AND_PRICE_set);
  SWIG_addvarlink(globals, "TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_AND_SIDE", Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_AND_SIDE_get, Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_AND_SIDE_set);
  SWIG_addvarlink(globals, "TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_PRICE_AND_SIDE", Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_PRICE_AND_SIDE_get, Swig_var_TriggerScope_ALL_OTHER_ORDERS_FOR_GIVEN_SECURITY_PRICE_AND_SIDE_set);
  SWIG_addvarlink(globals, "LimitAmtType_CREDIT_LIMIT", Swig_var_LimitAmtType_CREDIT_LIMIT_get, Swig_var_LimitAmtType_CREDIT_LIMIT_set);
  SWIG_addvarlink(globals, "LimitAmtType_GROSS_POSITION_LIMIT", Swig_var_LimitAmtType_GROSS_POSITION_LIMIT_get, Swig_var_LimitAmtType_GROSS_POSITION_LIMIT_set);
  SWIG_addvarlink(globals, "LimitAmtType_NET_POSITION_LIMIT", Swig_var_LimitAmtType_NET_POSITION_LIMIT_get, Swig_var_LimitAmtType_NET_POSITION_LIMIT_set);
  SWIG_addvarlink(globals, "LimitAmtType_RISK_EXPOSURE_LIMIT", Swig_var_LimitAmtType_RISK_EXPOSURE_LIMIT_get, Swig_var_LimitAmtType_RISK_EXPOSURE_LIMIT_set);
  SWIG_addvarlink(globals, "LimitAmtType_LONG_POSITION_LIMIT", Swig_var_LimitAmtType_LONG_POSITION_LIMIT_get, Swig_var_LimitAmtType_LONG_POSITION_LIMIT_set);
  SWIG_addvarlink(globals, "LimitAmtType_SHORT_POSITION_LIMIT", Swig_var_LimitAmtType_SHORT_POSITION_LIMIT_get, Swig_var_LimitAmtType_SHORT_POSITION_LIMIT_set);
  SWIG_addvarlink(globals, "MarginReqmtInqQualifier_SUMMARY", Swig_var_MarginReqmtInqQualifier_SUMMARY_get, Swig_var_MarginReqmtInqQualifier_SUMMARY_set);
  SWIG_addvarlink(globals, "MarginReqmtInqQualifier_DETAIL", Swig_var_MarginReqmtInqQualifier_DETAIL_get, Swig_var_MarginReqmtInqQualifier_DETAIL_set);
  SWIG_addvarlink(globals, "MarginReqmtInqQualifier_EXCESS_DEFICIT", Swig_var_MarginReqmtInqQualifier_EXCESS_DEFICIT_get, Swig_var_MarginReqmtInqQualifier_EXCESS_DEFICIT_set);
  SWIG_addvarlink(globals, "MarginReqmtInqQualifier_NET_POSITION", Swig_var_MarginReqmtInqQualifier_NET_POSITION_get, Swig_var_MarginReqmtInqQualifier_NET_POSITION_set);
  SWIG_addvarlink(globals, "MarginReqmtRptType_SUMMARY", Swig_var_MarginReqmtRptType_SUMMARY_get, Swig_var_MarginReqmtRptType_SUMMARY_set);
  SWIG_addvarlink(globals, "MarginReqmtRptType_DETAIL", Swig_var_MarginReqmtRptType_DETAIL_get, Swig_var_MarginReqmtRptType_DETAIL_set);
  SWIG_addvarlink(globals, "MarginReqmtRptType_EXCESS_DEFICIT", Swig_var_MarginReqmtRptType_EXCESS_DEFICIT_get, Swig_var_MarginReqmtRptType_EXCESS_DEFICIT_set);
  SWIG_addvarlink(globals, "MarginReqmtInqResult_SUCCESSFUL", Swig_var_MarginReqmtInqResult_SUCCESSFUL_get, Swig_var_MarginReqmtInqResult_SUCCESSFUL_set);
  SWIG_addvarlink(globals, "MarginReqmtInqResult_INVALID_OR_UNKNOWN_INSTRUMENT", Swig_var_MarginReqmtInqResult_INVALID_OR_UNKNOWN_INSTRUMENT_get, Swig_var_MarginReqmtInqResult_INVALID_OR_UNKNOWN_INSTRUMENT_set);
  SWIG_addvarlink(globals, "MarginReqmtInqResult_INVALID_OR_UNKNOWN_MARGIN_CLASS", Swig_var_MarginReqmtInqResult_INVALID_OR_UNKNOWN_MARGIN_CLASS_get, Swig_var_MarginReqmtInqResult_INVALID_OR_UNKNOWN_MARGIN_CLASS_set);
  SWIG_addvarlink(globals, "MarginReqmtInqResult_INVALID_PARTIES", Swig_var_MarginReqmtInqResult_INVALID_PARTIES_get, Swig_var_MarginReqmtInqResult_INVALID_PARTIES_set);
  SWIG_addvarlink(globals, "MarginReqmtInqResult_INVALID_TRANSPORT_TYPE_REQ", Swig_var_MarginReqmtInqResult_INVALID_TRANSPORT_TYPE_REQ_get, Swig_var_MarginReqmtInqResult_INVALID_TRANSPORT_TYPE_REQ_set);
  SWIG_addvarlink(globals, "MarginReqmtInqResult_INVALID_DESTINATION_REQ", Swig_var_MarginReqmtInqResult_INVALID_DESTINATION_REQ_get, Swig_var_MarginReqmtInqResult_INVALID_DESTINATION_REQ_set);
  SWIG_addvarlink(globals, "MarginReqmtInqResult_NO_MARGIN_REQ_FOUND", Swig_var_MarginReqmtInqResult_NO_MARGIN_REQ_FOUND_get, Swig_var_MarginReqmtInqResult_NO_MARGIN_REQ_FOUND_set);
  SWIG_addvarlink(globals, "MarginReqmtInqResult_MARGIN_REQ_INQUIRY_QUALIFIER_NOT_SUPPORTED", Swig_var_MarginReqmtInqResult_MARGIN_REQ_INQUIRY_QUALIFIER_NOT_SUPPORTED_get, Swig_var_MarginReqmtInqResult_MARGIN_REQ_INQUIRY_QUALIFIER_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "MarginReqmtInqResult_UNAUTHORIZED_FOR_MARGIN_REQ_INQUIRY", Swig_var_MarginReqmtInqResult_UNAUTHORIZED_FOR_MARGIN_REQ_INQUIRY_get, Swig_var_MarginReqmtInqResult_UNAUTHORIZED_FOR_MARGIN_REQ_INQUIRY_set);
  SWIG_addvarlink(globals, "MarginReqmtInqResult_OTHER", Swig_var_MarginReqmtInqResult_OTHER_get, Swig_var_MarginReqmtInqResult_OTHER_set);
  SWIG_addvarlink(globals, "MarginAmtType_ADDITIONAL_MARGIN", Swig_var_MarginAmtType_ADDITIONAL_MARGIN_get, Swig_var_MarginAmtType_ADDITIONAL_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_ADJUSTED_MARGIN", Swig_var_MarginAmtType_ADJUSTED_MARGIN_get, Swig_var_MarginAmtType_ADJUSTED_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_UNADJUSTED_MARGIN", Swig_var_MarginAmtType_UNADJUSTED_MARGIN_get, Swig_var_MarginAmtType_UNADJUSTED_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_BINARY_ADD_ON_AMOUNT", Swig_var_MarginAmtType_BINARY_ADD_ON_AMOUNT_get, Swig_var_MarginAmtType_BINARY_ADD_ON_AMOUNT_set);
  SWIG_addvarlink(globals, "MarginAmtType_CASH_BALANCE_AMOUNT", Swig_var_MarginAmtType_CASH_BALANCE_AMOUNT_get, Swig_var_MarginAmtType_CASH_BALANCE_AMOUNT_set);
  SWIG_addvarlink(globals, "MarginAmtType_CONCENTRATION_MARGIN", Swig_var_MarginAmtType_CONCENTRATION_MARGIN_get, Swig_var_MarginAmtType_CONCENTRATION_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_CORE_MARGIN", Swig_var_MarginAmtType_CORE_MARGIN_get, Swig_var_MarginAmtType_CORE_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_DELIVERY_MARGIN", Swig_var_MarginAmtType_DELIVERY_MARGIN_get, Swig_var_MarginAmtType_DELIVERY_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_DISCRETIONARY_MARGIN", Swig_var_MarginAmtType_DISCRETIONARY_MARGIN_get, Swig_var_MarginAmtType_DISCRETIONARY_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_FUTURES_SPREAD_MARGIN", Swig_var_MarginAmtType_FUTURES_SPREAD_MARGIN_get, Swig_var_MarginAmtType_FUTURES_SPREAD_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_INITIAL_MARGIN", Swig_var_MarginAmtType_INITIAL_MARGIN_get, Swig_var_MarginAmtType_INITIAL_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_LIQUIDATING_MARGIN", Swig_var_MarginAmtType_LIQUIDATING_MARGIN_get, Swig_var_MarginAmtType_LIQUIDATING_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_MARGIN_CALL_AMOUNT", Swig_var_MarginAmtType_MARGIN_CALL_AMOUNT_get, Swig_var_MarginAmtType_MARGIN_CALL_AMOUNT_set);
  SWIG_addvarlink(globals, "MarginAmtType_MARGIN_DEFICIT_AMOUNT", Swig_var_MarginAmtType_MARGIN_DEFICIT_AMOUNT_get, Swig_var_MarginAmtType_MARGIN_DEFICIT_AMOUNT_set);
  SWIG_addvarlink(globals, "MarginAmtType_MARGIN_EXCESS_AMOUNT", Swig_var_MarginAmtType_MARGIN_EXCESS_AMOUNT_get, Swig_var_MarginAmtType_MARGIN_EXCESS_AMOUNT_set);
  SWIG_addvarlink(globals, "MarginAmtType_OPTION_PREMIUM_AMOUNT", Swig_var_MarginAmtType_OPTION_PREMIUM_AMOUNT_get, Swig_var_MarginAmtType_OPTION_PREMIUM_AMOUNT_set);
  SWIG_addvarlink(globals, "MarginAmtType_PREMIUM_MARGIN", Swig_var_MarginAmtType_PREMIUM_MARGIN_get, Swig_var_MarginAmtType_PREMIUM_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_RESERVE_MARGIN", Swig_var_MarginAmtType_RESERVE_MARGIN_get, Swig_var_MarginAmtType_RESERVE_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_SECURITY_COLLATERAL_AMOUNT", Swig_var_MarginAmtType_SECURITY_COLLATERAL_AMOUNT_get, Swig_var_MarginAmtType_SECURITY_COLLATERAL_AMOUNT_set);
  SWIG_addvarlink(globals, "MarginAmtType_STRESS_TEST_ADD_ON_AMOUNT", Swig_var_MarginAmtType_STRESS_TEST_ADD_ON_AMOUNT_get, Swig_var_MarginAmtType_STRESS_TEST_ADD_ON_AMOUNT_set);
  SWIG_addvarlink(globals, "MarginAmtType_SUPER_MARGIN", Swig_var_MarginAmtType_SUPER_MARGIN_get, Swig_var_MarginAmtType_SUPER_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_TOTAL_MARGIN", Swig_var_MarginAmtType_TOTAL_MARGIN_get, Swig_var_MarginAmtType_TOTAL_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_VARIATION_MARGIN", Swig_var_MarginAmtType_VARIATION_MARGIN_get, Swig_var_MarginAmtType_VARIATION_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_SECONDARY_VARIATION_MARGIN", Swig_var_MarginAmtType_SECONDARY_VARIATION_MARGIN_get, Swig_var_MarginAmtType_SECONDARY_VARIATION_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_ROLLED_UP_MARGIN_DEFICIT", Swig_var_MarginAmtType_ROLLED_UP_MARGIN_DEFICIT_get, Swig_var_MarginAmtType_ROLLED_UP_MARGIN_DEFICIT_set);
  SWIG_addvarlink(globals, "MarginAmtType_SPREAD_RESPONSE_MARGIN", Swig_var_MarginAmtType_SPREAD_RESPONSE_MARGIN_get, Swig_var_MarginAmtType_SPREAD_RESPONSE_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_SYSTEMIC_RISK_MARGIN", Swig_var_MarginAmtType_SYSTEMIC_RISK_MARGIN_get, Swig_var_MarginAmtType_SYSTEMIC_RISK_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_CURVE_RISK_MARGIN", Swig_var_MarginAmtType_CURVE_RISK_MARGIN_get, Swig_var_MarginAmtType_CURVE_RISK_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_INDEX_SPREAD_RISK_MARGIN", Swig_var_MarginAmtType_INDEX_SPREAD_RISK_MARGIN_get, Swig_var_MarginAmtType_INDEX_SPREAD_RISK_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_SECTOR_RISK_MARGIN", Swig_var_MarginAmtType_SECTOR_RISK_MARGIN_get, Swig_var_MarginAmtType_SECTOR_RISK_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_JUMP_TO_DEFAULT_RISK_MARGIN", Swig_var_MarginAmtType_JUMP_TO_DEFAULT_RISK_MARGIN_get, Swig_var_MarginAmtType_JUMP_TO_DEFAULT_RISK_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_BASIS_RISK_MARGIN", Swig_var_MarginAmtType_BASIS_RISK_MARGIN_get, Swig_var_MarginAmtType_BASIS_RISK_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_INTEREST_RATE_RISK_MARGIN", Swig_var_MarginAmtType_INTEREST_RATE_RISK_MARGIN_get, Swig_var_MarginAmtType_INTEREST_RATE_RISK_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_JUMP_TO_HEALTH_RISK_MARGIN", Swig_var_MarginAmtType_JUMP_TO_HEALTH_RISK_MARGIN_get, Swig_var_MarginAmtType_JUMP_TO_HEALTH_RISK_MARGIN_set);
  SWIG_addvarlink(globals, "MarginAmtType_OTHER_RISK_MARGIN", Swig_var_MarginAmtType_OTHER_RISK_MARGIN_get, Swig_var_MarginAmtType_OTHER_RISK_MARGIN_set);
  SWIG_addvarlink(globals, "RelatedInstrumentType_HEDGES_FOR_INSTRUMENT", Swig_var_RelatedInstrumentType_HEDGES_FOR_INSTRUMENT_get, Swig_var_RelatedInstrumentType_HEDGES_FOR_INSTRUMENT_set);
  SWIG_addvarlink(globals, "RelatedInstrumentType_UNDERLIER", Swig_var_RelatedInstrumentType_UNDERLIER_get, Swig_var_RelatedInstrumentType_UNDERLIER_set);
  SWIG_addvarlink(globals, "RelatedInstrumentType_EQUITY_EQUIVALENT", Swig_var_RelatedInstrumentType_EQUITY_EQUIVALENT_get, Swig_var_RelatedInstrumentType_EQUITY_EQUIVALENT_set);
  SWIG_addvarlink(globals, "RelatedInstrumentType_NEAREST_EXCHANGE_TRADED_CONTRACT", Swig_var_RelatedInstrumentType_NEAREST_EXCHANGE_TRADED_CONTRACT_get, Swig_var_RelatedInstrumentType_NEAREST_EXCHANGE_TRADED_CONTRACT_set);
  SWIG_addvarlink(globals, "RelatedInstrumentType_RETAIL_EQUIVALENT", Swig_var_RelatedInstrumentType_RETAIL_EQUIVALENT_get, Swig_var_RelatedInstrumentType_RETAIL_EQUIVALENT_set);
  SWIG_addvarlink(globals, "RelatedInstrumentType_LEG", Swig_var_RelatedInstrumentType_LEG_get, Swig_var_RelatedInstrumentType_LEG_set);
  SWIG_addvarlink(globals, "MarketMakerActivity_NO_PARTICIPATION", Swig_var_MarketMakerActivity_NO_PARTICIPATION_get, Swig_var_MarketMakerActivity_NO_PARTICIPATION_set);
  SWIG_addvarlink(globals, "MarketMakerActivity_BUY_PARTICIPATION", Swig_var_MarketMakerActivity_BUY_PARTICIPATION_get, Swig_var_MarketMakerActivity_BUY_PARTICIPATION_set);
  SWIG_addvarlink(globals, "MarketMakerActivity_SELL_PARTICIPATION", Swig_var_MarketMakerActivity_SELL_PARTICIPATION_get, Swig_var_MarketMakerActivity_SELL_PARTICIPATION_set);
  SWIG_addvarlink(globals, "MarketMakerActivity_BOTH_BUY_AND_SELL_PARTICIPATION", Swig_var_MarketMakerActivity_BOTH_BUY_AND_SELL_PARTICIPATION_get, Swig_var_MarketMakerActivity_BOTH_BUY_AND_SELL_PARTICIPATION_set);
  SWIG_addvarlink(globals, "RequestResult_VALID_REQUEST", Swig_var_RequestResult_VALID_REQUEST_get, Swig_var_RequestResult_VALID_REQUEST_set);
  SWIG_addvarlink(globals, "RequestResult_INVALID_OR_UNSUPPORTED_REQUEST", Swig_var_RequestResult_INVALID_OR_UNSUPPORTED_REQUEST_get, Swig_var_RequestResult_INVALID_OR_UNSUPPORTED_REQUEST_set);
  SWIG_addvarlink(globals, "RequestResult_NO_DATA_FOUND", Swig_var_RequestResult_NO_DATA_FOUND_get, Swig_var_RequestResult_NO_DATA_FOUND_set);
  SWIG_addvarlink(globals, "RequestResult_NOT_AUTHORIZED", Swig_var_RequestResult_NOT_AUTHORIZED_get, Swig_var_RequestResult_NOT_AUTHORIZED_set);
  SWIG_addvarlink(globals, "RequestResult_DATA_TEMPORARILY_UNAVAILABLE", Swig_var_RequestResult_DATA_TEMPORARILY_UNAVAILABLE_get, Swig_var_RequestResult_DATA_TEMPORARILY_UNAVAILABLE_set);
  SWIG_addvarlink(globals, "RequestResult_REQUEST_FOR_DATA_NOT_SUPPORTED", Swig_var_RequestResult_REQUEST_FOR_DATA_NOT_SUPPORTED_get, Swig_var_RequestResult_REQUEST_FOR_DATA_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "RequestResult_OTHER", Swig_var_RequestResult_OTHER_get, Swig_var_RequestResult_OTHER_set);
  SWIG_addvarlink(globals, "PartyRelationship_IS_ALSO", Swig_var_PartyRelationship_IS_ALSO_get, Swig_var_PartyRelationship_IS_ALSO_set);
  SWIG_addvarlink(globals, "PartyRelationship_CLEARS_FOR", Swig_var_PartyRelationship_CLEARS_FOR_get, Swig_var_PartyRelationship_CLEARS_FOR_set);
  SWIG_addvarlink(globals, "PartyRelationship_CLEARS_THROUGH", Swig_var_PartyRelationship_CLEARS_THROUGH_get, Swig_var_PartyRelationship_CLEARS_THROUGH_set);
  SWIG_addvarlink(globals, "PartyRelationship_TRADES_FOR", Swig_var_PartyRelationship_TRADES_FOR_get, Swig_var_PartyRelationship_TRADES_FOR_set);
  SWIG_addvarlink(globals, "PartyRelationship_TRADES_THROUGH", Swig_var_PartyRelationship_TRADES_THROUGH_get, Swig_var_PartyRelationship_TRADES_THROUGH_set);
  SWIG_addvarlink(globals, "PartyRelationship_SPONSORS", Swig_var_PartyRelationship_SPONSORS_get, Swig_var_PartyRelationship_SPONSORS_set);
  SWIG_addvarlink(globals, "PartyRelationship_SPONSORED_THROUGH", Swig_var_PartyRelationship_SPONSORED_THROUGH_get, Swig_var_PartyRelationship_SPONSORED_THROUGH_set);
  SWIG_addvarlink(globals, "PartyRelationship_PROVIDES_GUARANTEE_FOR", Swig_var_PartyRelationship_PROVIDES_GUARANTEE_FOR_get, Swig_var_PartyRelationship_PROVIDES_GUARANTEE_FOR_set);
  SWIG_addvarlink(globals, "PartyRelationship_IS_GUARANTEED_BY", Swig_var_PartyRelationship_IS_GUARANTEED_BY_get, Swig_var_PartyRelationship_IS_GUARANTEED_BY_set);
  SWIG_addvarlink(globals, "PartyRelationship_MEMBER_OF", Swig_var_PartyRelationship_MEMBER_OF_get, Swig_var_PartyRelationship_MEMBER_OF_set);
  SWIG_addvarlink(globals, "PartyRelationship_HAS_MEMBERS", Swig_var_PartyRelationship_HAS_MEMBERS_get, Swig_var_PartyRelationship_HAS_MEMBERS_set);
  SWIG_addvarlink(globals, "PartyRelationship_PROVIDES_MARKETPLACE_FOR", Swig_var_PartyRelationship_PROVIDES_MARKETPLACE_FOR_get, Swig_var_PartyRelationship_PROVIDES_MARKETPLACE_FOR_set);
  SWIG_addvarlink(globals, "PartyRelationship_PARTICIPANT_OF_MARKETPLACE", Swig_var_PartyRelationship_PARTICIPANT_OF_MARKETPLACE_get, Swig_var_PartyRelationship_PARTICIPANT_OF_MARKETPLACE_set);
  SWIG_addvarlink(globals, "PartyRelationship_CARRIES_POSITIONS_FOR", Swig_var_PartyRelationship_CARRIES_POSITIONS_FOR_get, Swig_var_PartyRelationship_CARRIES_POSITIONS_FOR_set);
  SWIG_addvarlink(globals, "PartyRelationship_POSTS_TRADES_TO", Swig_var_PartyRelationship_POSTS_TRADES_TO_get, Swig_var_PartyRelationship_POSTS_TRADES_TO_set);
  SWIG_addvarlink(globals, "PartyRelationship_ENTERS_TRADES_FOR", Swig_var_PartyRelationship_ENTERS_TRADES_FOR_get, Swig_var_PartyRelationship_ENTERS_TRADES_FOR_set);
  SWIG_addvarlink(globals, "PartyRelationship_ENTERS_TRADES_THROUGH", Swig_var_PartyRelationship_ENTERS_TRADES_THROUGH_get, Swig_var_PartyRelationship_ENTERS_TRADES_THROUGH_set);
  SWIG_addvarlink(globals, "PartyRelationship_PROVIDES_QUOTES_TO", Swig_var_PartyRelationship_PROVIDES_QUOTES_TO_get, Swig_var_PartyRelationship_PROVIDES_QUOTES_TO_set);
  SWIG_addvarlink(globals, "PartyRelationship_REQUESTS_QUOTES_FROM", Swig_var_PartyRelationship_REQUESTS_QUOTES_FROM_get, Swig_var_PartyRelationship_REQUESTS_QUOTES_FROM_set);
  SWIG_addvarlink(globals, "PartyRelationship_INVESTS_FOR", Swig_var_PartyRelationship_INVESTS_FOR_get, Swig_var_PartyRelationship_INVESTS_FOR_set);
  SWIG_addvarlink(globals, "PartyRelationship_INVESTS_THROUGH", Swig_var_PartyRelationship_INVESTS_THROUGH_get, Swig_var_PartyRelationship_INVESTS_THROUGH_set);
  SWIG_addvarlink(globals, "PartyRelationship_BROKERS_TRADES_FOR", Swig_var_PartyRelationship_BROKERS_TRADES_FOR_get, Swig_var_PartyRelationship_BROKERS_TRADES_FOR_set);
  SWIG_addvarlink(globals, "PartyRelationship_BROKERS_TRADES_THROUGH", Swig_var_PartyRelationship_BROKERS_TRADES_THROUGH_get, Swig_var_PartyRelationship_BROKERS_TRADES_THROUGH_set);
  SWIG_addvarlink(globals, "PartyRelationship_PROVIDES_TRADING_SERVICES_FOR", Swig_var_PartyRelationship_PROVIDES_TRADING_SERVICES_FOR_get, Swig_var_PartyRelationship_PROVIDES_TRADING_SERVICES_FOR_set);
  SWIG_addvarlink(globals, "PartyRelationship_USES_TRADING_SERVICES_OF", Swig_var_PartyRelationship_USES_TRADING_SERVICES_OF_get, Swig_var_PartyRelationship_USES_TRADING_SERVICES_OF_set);
  SWIG_addvarlink(globals, "PartyRelationship_APPROVES_OF", Swig_var_PartyRelationship_APPROVES_OF_get, Swig_var_PartyRelationship_APPROVES_OF_set);
  SWIG_addvarlink(globals, "PartyRelationship_APPROVED_BY", Swig_var_PartyRelationship_APPROVED_BY_get, Swig_var_PartyRelationship_APPROVED_BY_set);
  SWIG_addvarlink(globals, "PartyRelationship_PARENT_FIRM_FOR", Swig_var_PartyRelationship_PARENT_FIRM_FOR_get, Swig_var_PartyRelationship_PARENT_FIRM_FOR_set);
  SWIG_addvarlink(globals, "PartyRelationship_SUBSIDIARY_OF", Swig_var_PartyRelationship_SUBSIDIARY_OF_get, Swig_var_PartyRelationship_SUBSIDIARY_OF_set);
  SWIG_addvarlink(globals, "PartyRelationship_REGULATORY_OWNER_OF", Swig_var_PartyRelationship_REGULATORY_OWNER_OF_get, Swig_var_PartyRelationship_REGULATORY_OWNER_OF_set);
  SWIG_addvarlink(globals, "PartyRelationship_OWNED_BY_REGULATORY", Swig_var_PartyRelationship_OWNED_BY_REGULATORY_get, Swig_var_PartyRelationship_OWNED_BY_REGULATORY_set);
  SWIG_addvarlink(globals, "PartyRelationship_CONTROLS", Swig_var_PartyRelationship_CONTROLS_get, Swig_var_PartyRelationship_CONTROLS_set);
  SWIG_addvarlink(globals, "PartyRelationship_IS_CONTROLLED_BY", Swig_var_PartyRelationship_IS_CONTROLLED_BY_get, Swig_var_PartyRelationship_IS_CONTROLLED_BY_set);
  SWIG_addvarlink(globals, "PartyRelationship_LEGAL_OWNER_OF", Swig_var_PartyRelationship_LEGAL_OWNER_OF_get, Swig_var_PartyRelationship_LEGAL_OWNER_OF_set);
  SWIG_addvarlink(globals, "PartyRelationship_OWNED_BY_LEGAL", Swig_var_PartyRelationship_OWNED_BY_LEGAL_get, Swig_var_PartyRelationship_OWNED_BY_LEGAL_set);
  SWIG_addvarlink(globals, "PartyRelationship_BENEFICIAL_OWNER_OF", Swig_var_PartyRelationship_BENEFICIAL_OWNER_OF_get, Swig_var_PartyRelationship_BENEFICIAL_OWNER_OF_set);
  SWIG_addvarlink(globals, "PartyRelationship_OWNED_BY_BENEFICIAL", Swig_var_PartyRelationship_OWNED_BY_BENEFICIAL_get, Swig_var_PartyRelationship_OWNED_BY_BENEFICIAL_set);
  SWIG_addvarlink(globals, "PartyRelationship_SETTLES_FOR", Swig_var_PartyRelationship_SETTLES_FOR_get, Swig_var_PartyRelationship_SETTLES_FOR_set);
  SWIG_addvarlink(globals, "PartyRelationship_SETTLES_THROUGH", Swig_var_PartyRelationship_SETTLES_THROUGH_get, Swig_var_PartyRelationship_SETTLES_THROUGH_set);
  SWIG_addvarlink(globals, "RiskLimitType_CREDIT_LIMIT", Swig_var_RiskLimitType_CREDIT_LIMIT_get, Swig_var_RiskLimitType_CREDIT_LIMIT_set);
  SWIG_addvarlink(globals, "RiskLimitType_GROSS_LIMIT", Swig_var_RiskLimitType_GROSS_LIMIT_get, Swig_var_RiskLimitType_GROSS_LIMIT_set);
  SWIG_addvarlink(globals, "RiskLimitType_NET_LIMIT", Swig_var_RiskLimitType_NET_LIMIT_get, Swig_var_RiskLimitType_NET_LIMIT_set);
  SWIG_addvarlink(globals, "RiskLimitType_EXPOSURE", Swig_var_RiskLimitType_EXPOSURE_get, Swig_var_RiskLimitType_EXPOSURE_set);
  SWIG_addvarlink(globals, "RiskLimitType_LONG_LIMIT", Swig_var_RiskLimitType_LONG_LIMIT_get, Swig_var_RiskLimitType_LONG_LIMIT_set);
  SWIG_addvarlink(globals, "RiskLimitType_SHORT_LIMIT", Swig_var_RiskLimitType_SHORT_LIMIT_get, Swig_var_RiskLimitType_SHORT_LIMIT_set);
  SWIG_addvarlink(globals, "RiskLimitType_CASH_MARGIN", Swig_var_RiskLimitType_CASH_MARGIN_get, Swig_var_RiskLimitType_CASH_MARGIN_set);
  SWIG_addvarlink(globals, "RiskLimitType_ADDITIONAL_MARGIN", Swig_var_RiskLimitType_ADDITIONAL_MARGIN_get, Swig_var_RiskLimitType_ADDITIONAL_MARGIN_set);
  SWIG_addvarlink(globals, "RiskLimitType_TOTAL_MARGIN", Swig_var_RiskLimitType_TOTAL_MARGIN_get, Swig_var_RiskLimitType_TOTAL_MARGIN_set);
  SWIG_addvarlink(globals, "RiskLimitType_LIMIT_CONSUMED", Swig_var_RiskLimitType_LIMIT_CONSUMED_get, Swig_var_RiskLimitType_LIMIT_CONSUMED_set);
  SWIG_addvarlink(globals, "RiskLimitType_CLIP_SIZE", Swig_var_RiskLimitType_CLIP_SIZE_get, Swig_var_RiskLimitType_CLIP_SIZE_set);
  SWIG_addvarlink(globals, "RiskLimitType_MAX_NOTIONAL_ORDER_SIZE", Swig_var_RiskLimitType_MAX_NOTIONAL_ORDER_SIZE_get, Swig_var_RiskLimitType_MAX_NOTIONAL_ORDER_SIZE_set);
  SWIG_addvarlink(globals, "RiskLimitType_DV01_PV01_LIMIT", Swig_var_RiskLimitType_DV01_PV01_LIMIT_get, Swig_var_RiskLimitType_DV01_PV01_LIMIT_set);
  SWIG_addvarlink(globals, "RiskLimitType_CS01_LIMIT", Swig_var_RiskLimitType_CS01_LIMIT_get, Swig_var_RiskLimitType_CS01_LIMIT_set);
  SWIG_addvarlink(globals, "RiskLimitType_VOLUME_LIMIT_PER_TIME_PERIOD", Swig_var_RiskLimitType_VOLUME_LIMIT_PER_TIME_PERIOD_get, Swig_var_RiskLimitType_VOLUME_LIMIT_PER_TIME_PERIOD_set);
  SWIG_addvarlink(globals, "RiskLimitType_VOL_FILLED_PCT_ORD_VOL_TM_PERIOD", Swig_var_RiskLimitType_VOL_FILLED_PCT_ORD_VOL_TM_PERIOD_get, Swig_var_RiskLimitType_VOL_FILLED_PCT_ORD_VOL_TM_PERIOD_set);
  SWIG_addvarlink(globals, "RiskLimitType_NOTL_FILLED_PCT_NOTL_TM_PERIOD", Swig_var_RiskLimitType_NOTL_FILLED_PCT_NOTL_TM_PERIOD_get, Swig_var_RiskLimitType_NOTL_FILLED_PCT_NOTL_TM_PERIOD_set);
  SWIG_addvarlink(globals, "RiskLimitType_TRANSACTION_EXECUTION_LIMIT_PER_TIME_PERIOD", Swig_var_RiskLimitType_TRANSACTION_EXECUTION_LIMIT_PER_TIME_PERIOD_get, Swig_var_RiskLimitType_TRANSACTION_EXECUTION_LIMIT_PER_TIME_PERIOD_set);
  SWIG_addvarlink(globals, "InstrumentScopeOperator_INCLUDE", Swig_var_InstrumentScopeOperator_INCLUDE_get, Swig_var_InstrumentScopeOperator_INCLUDE_set);
  SWIG_addvarlink(globals, "InstrumentScopeOperator_EXCLUDE", Swig_var_InstrumentScopeOperator_EXCLUDE_get, Swig_var_InstrumentScopeOperator_EXCLUDE_set);
  SWIG_addvarlink(globals, "PartyDetailStatus_ACTIVE", Swig_var_PartyDetailStatus_ACTIVE_get, Swig_var_PartyDetailStatus_ACTIVE_set);
  SWIG_addvarlink(globals, "PartyDetailStatus_SUSPENDED", Swig_var_PartyDetailStatus_SUSPENDED_get, Swig_var_PartyDetailStatus_SUSPENDED_set);
  SWIG_addvarlink(globals, "PartyDetailStatus_HALTED", Swig_var_PartyDetailStatus_HALTED_get, Swig_var_PartyDetailStatus_HALTED_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_FIRM_OR_LEGAL_ENTITY", Swig_var_PartyDetailRoleQualifier_FIRM_OR_LEGAL_ENTITY_get, Swig_var_PartyDetailRoleQualifier_FIRM_OR_LEGAL_ENTITY_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_CURRENT", Swig_var_PartyDetailRoleQualifier_CURRENT_get, Swig_var_PartyDetailRoleQualifier_CURRENT_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_NEW", Swig_var_PartyDetailRoleQualifier_NEW_get, Swig_var_PartyDetailRoleQualifier_NEW_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_NATURAL_PERSON", Swig_var_PartyDetailRoleQualifier_NATURAL_PERSON_get, Swig_var_PartyDetailRoleQualifier_NATURAL_PERSON_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_AGENCY", Swig_var_PartyDetailRoleQualifier_AGENCY_get, Swig_var_PartyDetailRoleQualifier_AGENCY_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_PRINCIPAL", Swig_var_PartyDetailRoleQualifier_PRINCIPAL_get, Swig_var_PartyDetailRoleQualifier_PRINCIPAL_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_RISKLESS_PRINCIPAL", Swig_var_PartyDetailRoleQualifier_RISKLESS_PRINCIPAL_get, Swig_var_PartyDetailRoleQualifier_RISKLESS_PRINCIPAL_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_EXCHANGE_ORDER_SUBMITTER", Swig_var_PartyDetailRoleQualifier_EXCHANGE_ORDER_SUBMITTER_get, Swig_var_PartyDetailRoleQualifier_EXCHANGE_ORDER_SUBMITTER_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_PRIMARY_TRD_REPOSITORY", Swig_var_PartyDetailRoleQualifier_PRIMARY_TRD_REPOSITORY_get, Swig_var_PartyDetailRoleQualifier_PRIMARY_TRD_REPOSITORY_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_ORIG_TRD_REPOSITORY", Swig_var_PartyDetailRoleQualifier_ORIG_TRD_REPOSITORY_get, Swig_var_PartyDetailRoleQualifier_ORIG_TRD_REPOSITORY_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_ADDTNL_INTL_TRD_REPOSITORY", Swig_var_PartyDetailRoleQualifier_ADDTNL_INTL_TRD_REPOSITORY_get, Swig_var_PartyDetailRoleQualifier_ADDTNL_INTL_TRD_REPOSITORY_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_ADDTNL_DOMESTIC_TRD_REPOSITORY", Swig_var_PartyDetailRoleQualifier_ADDTNL_DOMESTIC_TRD_REPOSITORY_get, Swig_var_PartyDetailRoleQualifier_ADDTNL_DOMESTIC_TRD_REPOSITORY_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_REGULAR_TRADER", Swig_var_PartyDetailRoleQualifier_REGULAR_TRADER_get, Swig_var_PartyDetailRoleQualifier_REGULAR_TRADER_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_HEAD_TRADER", Swig_var_PartyDetailRoleQualifier_HEAD_TRADER_get, Swig_var_PartyDetailRoleQualifier_HEAD_TRADER_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_SUPERVISOR", Swig_var_PartyDetailRoleQualifier_SUPERVISOR_get, Swig_var_PartyDetailRoleQualifier_SUPERVISOR_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_ALGORITHM", Swig_var_PartyDetailRoleQualifier_ALGORITHM_get, Swig_var_PartyDetailRoleQualifier_ALGORITHM_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_RELATED_EXCHANGE", Swig_var_PartyDetailRoleQualifier_RELATED_EXCHANGE_get, Swig_var_PartyDetailRoleQualifier_RELATED_EXCHANGE_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_OPTIONS_EXCHANGE", Swig_var_PartyDetailRoleQualifier_OPTIONS_EXCHANGE_get, Swig_var_PartyDetailRoleQualifier_OPTIONS_EXCHANGE_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_SPECIFIED_EXCHANGE", Swig_var_PartyDetailRoleQualifier_SPECIFIED_EXCHANGE_get, Swig_var_PartyDetailRoleQualifier_SPECIFIED_EXCHANGE_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_CONSTITUENT_EXCHANGE", Swig_var_PartyDetailRoleQualifier_CONSTITUENT_EXCHANGE_get, Swig_var_PartyDetailRoleQualifier_CONSTITUENT_EXCHANGE_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_BANK", Swig_var_PartyDetailRoleQualifier_BANK_get, Swig_var_PartyDetailRoleQualifier_BANK_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_HUB", Swig_var_PartyDetailRoleQualifier_HUB_get, Swig_var_PartyDetailRoleQualifier_HUB_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_TRI_PARTY", Swig_var_PartyDetailRoleQualifier_TRI_PARTY_get, Swig_var_PartyDetailRoleQualifier_TRI_PARTY_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_LENDER", Swig_var_PartyDetailRoleQualifier_LENDER_get, Swig_var_PartyDetailRoleQualifier_LENDER_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_GENERAL_CLEARING_MEMBER", Swig_var_PartyDetailRoleQualifier_GENERAL_CLEARING_MEMBER_get, Swig_var_PartyDetailRoleQualifier_GENERAL_CLEARING_MEMBER_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_INDIVIDUAL_CLEARING_MEMBER", Swig_var_PartyDetailRoleQualifier_INDIVIDUAL_CLEARING_MEMBER_get, Swig_var_PartyDetailRoleQualifier_INDIVIDUAL_CLEARING_MEMBER_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_PREFERRED_MARKET_MAKER", Swig_var_PartyDetailRoleQualifier_PREFERRED_MARKET_MAKER_get, Swig_var_PartyDetailRoleQualifier_PREFERRED_MARKET_MAKER_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_DIRECTED_MARKET_MAKER", Swig_var_PartyDetailRoleQualifier_DIRECTED_MARKET_MAKER_get, Swig_var_PartyDetailRoleQualifier_DIRECTED_MARKET_MAKER_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_DESIGNATED_SPONSOR", Swig_var_PartyDetailRoleQualifier_DESIGNATED_SPONSOR_get, Swig_var_PartyDetailRoleQualifier_DESIGNATED_SPONSOR_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_SPECIALIST", Swig_var_PartyDetailRoleQualifier_SPECIALIST_get, Swig_var_PartyDetailRoleQualifier_SPECIALIST_set);
  SWIG_addvarlink(globals, "PartyDetailRoleQualifier_EXEMPT_FROM_TRADE_REPORTING", Swig_var_PartyDetailRoleQualifier_EXEMPT_FROM_TRADE_REPORTING_get, Swig_var_PartyDetailRoleQualifier_EXEMPT_FROM_TRADE_REPORTING_set);
  SWIG_addvarlink(globals, "TrdAckStatus_ACCEPTED", Swig_var_TrdAckStatus_ACCEPTED_get, Swig_var_TrdAckStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "TrdAckStatus_REJECTED", Swig_var_TrdAckStatus_REJECTED_get, Swig_var_TrdAckStatus_REJECTED_set);
  SWIG_addvarlink(globals, "TrdAckStatus_RECEIVED", Swig_var_TrdAckStatus_RECEIVED_get, Swig_var_TrdAckStatus_RECEIVED_set);
  SWIG_addvarlink(globals, "SecurityClassificationReason_FEE", Swig_var_SecurityClassificationReason_FEE_get, Swig_var_SecurityClassificationReason_FEE_set);
  SWIG_addvarlink(globals, "SecurityClassificationReason_CREDIT_CONTROLS", Swig_var_SecurityClassificationReason_CREDIT_CONTROLS_get, Swig_var_SecurityClassificationReason_CREDIT_CONTROLS_set);
  SWIG_addvarlink(globals, "SecurityClassificationReason_MARGIN", Swig_var_SecurityClassificationReason_MARGIN_get, Swig_var_SecurityClassificationReason_MARGIN_set);
  SWIG_addvarlink(globals, "SecurityClassificationReason_ENTITLEMENT_OR_ELIGIBILITY", Swig_var_SecurityClassificationReason_ENTITLEMENT_OR_ELIGIBILITY_get, Swig_var_SecurityClassificationReason_ENTITLEMENT_OR_ELIGIBILITY_set);
  SWIG_addvarlink(globals, "SecurityClassificationReason_MARKET_DATA", Swig_var_SecurityClassificationReason_MARKET_DATA_get, Swig_var_SecurityClassificationReason_MARKET_DATA_set);
  SWIG_addvarlink(globals, "SecurityClassificationReason_ACCOUNT_SELECTION", Swig_var_SecurityClassificationReason_ACCOUNT_SELECTION_get, Swig_var_SecurityClassificationReason_ACCOUNT_SELECTION_set);
  SWIG_addvarlink(globals, "SecurityClassificationReason_DELIVERY_PROCESS", Swig_var_SecurityClassificationReason_DELIVERY_PROCESS_get, Swig_var_SecurityClassificationReason_DELIVERY_PROCESS_set);
  SWIG_addvarlink(globals, "SecurityClassificationReason_SECTOR", Swig_var_SecurityClassificationReason_SECTOR_get, Swig_var_SecurityClassificationReason_SECTOR_set);
  SWIG_addvarlink(globals, "PosAmtReason_OPTIONS_SETTLEMENT", Swig_var_PosAmtReason_OPTIONS_SETTLEMENT_get, Swig_var_PosAmtReason_OPTIONS_SETTLEMENT_set);
  SWIG_addvarlink(globals, "PosAmtReason_PENDING_EROSION_ADJUSTMENT", Swig_var_PosAmtReason_PENDING_EROSION_ADJUSTMENT_get, Swig_var_PosAmtReason_PENDING_EROSION_ADJUSTMENT_set);
  SWIG_addvarlink(globals, "PosAmtReason_FINAL_EROSION_ADJUSTMENT", Swig_var_PosAmtReason_FINAL_EROSION_ADJUSTMENT_get, Swig_var_PosAmtReason_FINAL_EROSION_ADJUSTMENT_set);
  SWIG_addvarlink(globals, "PosAmtReason_TEAR_UP_COUPON_AMOUNT", Swig_var_PosAmtReason_TEAR_UP_COUPON_AMOUNT_get, Swig_var_PosAmtReason_TEAR_UP_COUPON_AMOUNT_set);
  SWIG_addvarlink(globals, "PosAmtReason_PRICE_ALIGNMENT_INTEREST", Swig_var_PosAmtReason_PRICE_ALIGNMENT_INTEREST_get, Swig_var_PosAmtReason_PRICE_ALIGNMENT_INTEREST_set);
  SWIG_addvarlink(globals, "PosAmtReason_DELIVERY_INVOICE_CHARGES", Swig_var_PosAmtReason_DELIVERY_INVOICE_CHARGES_get, Swig_var_PosAmtReason_DELIVERY_INVOICE_CHARGES_set);
  SWIG_addvarlink(globals, "PosAmtReason_DELIVERY_STORAGE_CHARGES", Swig_var_PosAmtReason_DELIVERY_STORAGE_CHARGES_get, Swig_var_PosAmtReason_DELIVERY_STORAGE_CHARGES_set);
  SWIG_addvarlink(globals, "SideClearingTradePriceType_TRADE_CLEARING_AT_EXECUTION_PRICE", Swig_var_SideClearingTradePriceType_TRADE_CLEARING_AT_EXECUTION_PRICE_get, Swig_var_SideClearingTradePriceType_TRADE_CLEARING_AT_EXECUTION_PRICE_set);
  SWIG_addvarlink(globals, "SideClearingTradePriceType_TRADE_CLEARING_AT_ALTERNATE_CLEARING_PRICE", Swig_var_SideClearingTradePriceType_TRADE_CLEARING_AT_ALTERNATE_CLEARING_PRICE_get, Swig_var_SideClearingTradePriceType_TRADE_CLEARING_AT_ALTERNATE_CLEARING_PRICE_set);
  SWIG_addvarlink(globals, "SecurityRejectReason_INVALID_INSTRUMENT_REQUESTED", Swig_var_SecurityRejectReason_INVALID_INSTRUMENT_REQUESTED_get, Swig_var_SecurityRejectReason_INVALID_INSTRUMENT_REQUESTED_set);
  SWIG_addvarlink(globals, "SecurityRejectReason_INSTRUMENT_ALREADY_EXISTS", Swig_var_SecurityRejectReason_INSTRUMENT_ALREADY_EXISTS_get, Swig_var_SecurityRejectReason_INSTRUMENT_ALREADY_EXISTS_set);
  SWIG_addvarlink(globals, "SecurityRejectReason_REQUEST_TYPE_NOT_SUPPORTED", Swig_var_SecurityRejectReason_REQUEST_TYPE_NOT_SUPPORTED_get, Swig_var_SecurityRejectReason_REQUEST_TYPE_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "SecurityRejectReason_SYSTEM_UNAVAILABLE_FOR_INSTRUMENT_CREATION", Swig_var_SecurityRejectReason_SYSTEM_UNAVAILABLE_FOR_INSTRUMENT_CREATION_get, Swig_var_SecurityRejectReason_SYSTEM_UNAVAILABLE_FOR_INSTRUMENT_CREATION_set);
  SWIG_addvarlink(globals, "SecurityRejectReason_INELIGIBLE_INSTRUMENT_GROUP", Swig_var_SecurityRejectReason_INELIGIBLE_INSTRUMENT_GROUP_get, Swig_var_SecurityRejectReason_INELIGIBLE_INSTRUMENT_GROUP_set);
  SWIG_addvarlink(globals, "SecurityRejectReason_INSTRUMENT_ID_UNAVAILABLE", Swig_var_SecurityRejectReason_INSTRUMENT_ID_UNAVAILABLE_get, Swig_var_SecurityRejectReason_INSTRUMENT_ID_UNAVAILABLE_set);
  SWIG_addvarlink(globals, "SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_OPTION_LEG", Swig_var_SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_OPTION_LEG_get, Swig_var_SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_OPTION_LEG_set);
  SWIG_addvarlink(globals, "SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_FUTURE_LEG", Swig_var_SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_FUTURE_LEG_get, Swig_var_SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_FUTURE_LEG_set);
  SWIG_addvarlink(globals, "SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_FX_LEG", Swig_var_SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_FX_LEG_get, Swig_var_SecurityRejectReason_INVALID_OR_MISSING_DATA_ON_FX_LEG_set);
  SWIG_addvarlink(globals, "SecurityRejectReason_INVALID_LEG_PRICE_SPECIFIED", Swig_var_SecurityRejectReason_INVALID_LEG_PRICE_SPECIFIED_get, Swig_var_SecurityRejectReason_INVALID_LEG_PRICE_SPECIFIED_set);
  SWIG_addvarlink(globals, "SecurityRejectReason_INVALID_INSTRUMENT_STRUCTURE_SPECIFIED", Swig_var_SecurityRejectReason_INVALID_INSTRUMENT_STRUCTURE_SPECIFIED_get, Swig_var_SecurityRejectReason_INVALID_INSTRUMENT_STRUCTURE_SPECIFIED_set);
  SWIG_addvarlink(globals, "ThrottleStatus_THROTTLE_LIMIT_NOT_EXCEEDED_NOT_QUEUED", Swig_var_ThrottleStatus_THROTTLE_LIMIT_NOT_EXCEEDED_NOT_QUEUED_get, Swig_var_ThrottleStatus_THROTTLE_LIMIT_NOT_EXCEEDED_NOT_QUEUED_set);
  SWIG_addvarlink(globals, "ThrottleStatus_QUEUED_DUE_TO_THROTTLE_LIMIT_EXCEEDED", Swig_var_ThrottleStatus_QUEUED_DUE_TO_THROTTLE_LIMIT_EXCEEDED_get, Swig_var_ThrottleStatus_QUEUED_DUE_TO_THROTTLE_LIMIT_EXCEEDED_set);
  SWIG_addvarlink(globals, "ThrottleAction_QUEUE_INBOUND", Swig_var_ThrottleAction_QUEUE_INBOUND_get, Swig_var_ThrottleAction_QUEUE_INBOUND_set);
  SWIG_addvarlink(globals, "ThrottleAction_QUEUE_OUTBOUND", Swig_var_ThrottleAction_QUEUE_OUTBOUND_get, Swig_var_ThrottleAction_QUEUE_OUTBOUND_set);
  SWIG_addvarlink(globals, "ThrottleAction_REJECT", Swig_var_ThrottleAction_REJECT_get, Swig_var_ThrottleAction_REJECT_set);
  SWIG_addvarlink(globals, "ThrottleAction_DISCONNECT", Swig_var_ThrottleAction_DISCONNECT_get, Swig_var_ThrottleAction_DISCONNECT_set);
  SWIG_addvarlink(globals, "ThrottleAction_WARNING", Swig_var_ThrottleAction_WARNING_get, Swig_var_ThrottleAction_WARNING_set);
  SWIG_addvarlink(globals, "ThrottleType_INBOUND_RATE", Swig_var_ThrottleType_INBOUND_RATE_get, Swig_var_ThrottleType_INBOUND_RATE_set);
  SWIG_addvarlink(globals, "ThrottleType_OUTSTANDING_REQUESTS", Swig_var_ThrottleType_OUTSTANDING_REQUESTS_get, Swig_var_ThrottleType_OUTSTANDING_REQUESTS_set);
  SWIG_addvarlink(globals, "ThrottleInst_REJECT_IF_THROTTLE_LIMIT_EXCEEDED", Swig_var_ThrottleInst_REJECT_IF_THROTTLE_LIMIT_EXCEEDED_get, Swig_var_ThrottleInst_REJECT_IF_THROTTLE_LIMIT_EXCEEDED_set);
  SWIG_addvarlink(globals, "ThrottleInst_QUEUE_IF_THROTTLE_LIMIT_EXCEEDED", Swig_var_ThrottleInst_QUEUE_IF_THROTTLE_LIMIT_EXCEEDED_get, Swig_var_ThrottleInst_QUEUE_IF_THROTTLE_LIMIT_EXCEEDED_set);
  SWIG_addvarlink(globals, "ThrottleCountIndicator_OUTSTANDING_REQUESTS_UNCHANGED", Swig_var_ThrottleCountIndicator_OUTSTANDING_REQUESTS_UNCHANGED_get, Swig_var_ThrottleCountIndicator_OUTSTANDING_REQUESTS_UNCHANGED_set);
  SWIG_addvarlink(globals, "ThrottleCountIndicator_OUTSTANDING_REQUESTS_DECREASED", Swig_var_ThrottleCountIndicator_OUTSTANDING_REQUESTS_DECREASED_get, Swig_var_ThrottleCountIndicator_OUTSTANDING_REQUESTS_DECREASED_set);
  SWIG_addvarlink(globals, "AllocationRollupInstruction_ROLLUP", Swig_var_AllocationRollupInstruction_ROLLUP_get, Swig_var_AllocationRollupInstruction_ROLLUP_set);
  SWIG_addvarlink(globals, "AllocationRollupInstruction_DO_NOT_ROLL_UP", Swig_var_AllocationRollupInstruction_DO_NOT_ROLL_UP_get, Swig_var_AllocationRollupInstruction_DO_NOT_ROLL_UP_set);
  SWIG_addvarlink(globals, "AllocReversalStatus_COMPLETED", Swig_var_AllocReversalStatus_COMPLETED_get, Swig_var_AllocReversalStatus_COMPLETED_set);
  SWIG_addvarlink(globals, "AllocReversalStatus_REFUSED", Swig_var_AllocReversalStatus_REFUSED_get, Swig_var_AllocReversalStatus_REFUSED_set);
  SWIG_addvarlink(globals, "AllocReversalStatus_CANCELLED", Swig_var_AllocReversalStatus_CANCELLED_get, Swig_var_AllocReversalStatus_CANCELLED_set);
  SWIG_addvarlink(globals, "ObligationType_BOND", Swig_var_ObligationType_BOND_get, Swig_var_ObligationType_BOND_set);
  SWIG_addvarlink(globals, "ObligationType_CONVERT_BOND", Swig_var_ObligationType_CONVERT_BOND_get, Swig_var_ObligationType_CONVERT_BOND_set);
  SWIG_addvarlink(globals, "ObligationType_MORTGAGE", Swig_var_ObligationType_MORTGAGE_get, Swig_var_ObligationType_MORTGAGE_set);
  SWIG_addvarlink(globals, "ObligationType_LOAN", Swig_var_ObligationType_LOAN_get, Swig_var_ObligationType_LOAN_set);
  SWIG_addvarlink(globals, "TradePriceNegotiationMethod_PERCENT_PAR", Swig_var_TradePriceNegotiationMethod_PERCENT_PAR_get, Swig_var_TradePriceNegotiationMethod_PERCENT_PAR_set);
  SWIG_addvarlink(globals, "TradePriceNegotiationMethod_DEAL_SPREAD", Swig_var_TradePriceNegotiationMethod_DEAL_SPREAD_get, Swig_var_TradePriceNegotiationMethod_DEAL_SPREAD_set);
  SWIG_addvarlink(globals, "TradePriceNegotiationMethod_UPFRONT_PNTS", Swig_var_TradePriceNegotiationMethod_UPFRONT_PNTS_get, Swig_var_TradePriceNegotiationMethod_UPFRONT_PNTS_set);
  SWIG_addvarlink(globals, "TradePriceNegotiationMethod_UPFRONT_AMT", Swig_var_TradePriceNegotiationMethod_UPFRONT_AMT_get, Swig_var_TradePriceNegotiationMethod_UPFRONT_AMT_set);
  SWIG_addvarlink(globals, "TradePriceNegotiationMethod_PAR_UPFRONT_AMT", Swig_var_TradePriceNegotiationMethod_PAR_UPFRONT_AMT_get, Swig_var_TradePriceNegotiationMethod_PAR_UPFRONT_AMT_set);
  SWIG_addvarlink(globals, "TradePriceNegotiationMethod_SPREAD_UPFRONT_AMT", Swig_var_TradePriceNegotiationMethod_SPREAD_UPFRONT_AMT_get, Swig_var_TradePriceNegotiationMethod_SPREAD_UPFRONT_AMT_set);
  SWIG_addvarlink(globals, "TradePriceNegotiationMethod_UPFRONT_PNTS_AMT", Swig_var_TradePriceNegotiationMethod_UPFRONT_PNTS_AMT_get, Swig_var_TradePriceNegotiationMethod_UPFRONT_PNTS_AMT_set);
  SWIG_addvarlink(globals, "UpfrontPriceType_PERCENTAGE", Swig_var_UpfrontPriceType_PERCENTAGE_get, Swig_var_UpfrontPriceType_PERCENTAGE_set);
  SWIG_addvarlink(globals, "UpfrontPriceType_FIXED_AMOUNT", Swig_var_UpfrontPriceType_FIXED_AMOUNT_get, Swig_var_UpfrontPriceType_FIXED_AMOUNT_set);
  SWIG_addvarlink(globals, "ShortSaleRestriction_NO_RESTRICTIONS", Swig_var_ShortSaleRestriction_NO_RESTRICTIONS_get, Swig_var_ShortSaleRestriction_NO_RESTRICTIONS_set);
  SWIG_addvarlink(globals, "ShortSaleRestriction_SECURITY_NOT_SHORTABLE", Swig_var_ShortSaleRestriction_SECURITY_NOT_SHORTABLE_get, Swig_var_ShortSaleRestriction_SECURITY_NOT_SHORTABLE_set);
  SWIG_addvarlink(globals, "ShortSaleRestriction_SECURITY_NOT_SHORTABLE_AT_OR_BELOW_BEST_BID", Swig_var_ShortSaleRestriction_SECURITY_NOT_SHORTABLE_AT_OR_BELOW_BEST_BID_get, Swig_var_ShortSaleRestriction_SECURITY_NOT_SHORTABLE_AT_OR_BELOW_BEST_BID_set);
  SWIG_addvarlink(globals, "ShortSaleRestriction_SECURITY_NOT_SHORTABLE_WITHOUT_PRE_BORROW", Swig_var_ShortSaleRestriction_SECURITY_NOT_SHORTABLE_WITHOUT_PRE_BORROW_get, Swig_var_ShortSaleRestriction_SECURITY_NOT_SHORTABLE_WITHOUT_PRE_BORROW_set);
  SWIG_addvarlink(globals, "ShortSaleExemptionReason_EXEMPTION_REASON_UNKNOWN", Swig_var_ShortSaleExemptionReason_EXEMPTION_REASON_UNKNOWN_get, Swig_var_ShortSaleExemptionReason_EXEMPTION_REASON_UNKNOWN_set);
  SWIG_addvarlink(globals, "ShortSaleExemptionReason_INCOMING_SSE", Swig_var_ShortSaleExemptionReason_INCOMING_SSE_get, Swig_var_ShortSaleExemptionReason_INCOMING_SSE_set);
  SWIG_addvarlink(globals, "ShortSaleExemptionReason_ABOVE_NATIONAL_BEST_BID", Swig_var_ShortSaleExemptionReason_ABOVE_NATIONAL_BEST_BID_get, Swig_var_ShortSaleExemptionReason_ABOVE_NATIONAL_BEST_BID_set);
  SWIG_addvarlink(globals, "ShortSaleExemptionReason_DELAYED_DELIVERY", Swig_var_ShortSaleExemptionReason_DELAYED_DELIVERY_get, Swig_var_ShortSaleExemptionReason_DELAYED_DELIVERY_set);
  SWIG_addvarlink(globals, "ShortSaleExemptionReason_ODD_LOT", Swig_var_ShortSaleExemptionReason_ODD_LOT_get, Swig_var_ShortSaleExemptionReason_ODD_LOT_set);
  SWIG_addvarlink(globals, "ShortSaleExemptionReason_DOMESTIC_ARBITRAGE", Swig_var_ShortSaleExemptionReason_DOMESTIC_ARBITRAGE_get, Swig_var_ShortSaleExemptionReason_DOMESTIC_ARBITRAGE_set);
  SWIG_addvarlink(globals, "ShortSaleExemptionReason_INTERNATIONAL_ARBITRAGE", Swig_var_ShortSaleExemptionReason_INTERNATIONAL_ARBITRAGE_get, Swig_var_ShortSaleExemptionReason_INTERNATIONAL_ARBITRAGE_set);
  SWIG_addvarlink(globals, "ShortSaleExemptionReason_UNDERWRITER_OR_SYNDICATE_DISTRIBUTION", Swig_var_ShortSaleExemptionReason_UNDERWRITER_OR_SYNDICATE_DISTRIBUTION_get, Swig_var_ShortSaleExemptionReason_UNDERWRITER_OR_SYNDICATE_DISTRIBUTION_set);
  SWIG_addvarlink(globals, "ShortSaleExemptionReason_RISKLESS_PRINCIPAL", Swig_var_ShortSaleExemptionReason_RISKLESS_PRINCIPAL_get, Swig_var_ShortSaleExemptionReason_RISKLESS_PRINCIPAL_set);
  SWIG_addvarlink(globals, "ShortSaleExemptionReason_VWAP", Swig_var_ShortSaleExemptionReason_VWAP_get, Swig_var_ShortSaleExemptionReason_VWAP_set);
  SWIG_addvarlink(globals, "ApplLevelRecoveryIndicator_NO_APPL_RECOVERY_NEEDED", Swig_var_ApplLevelRecoveryIndicator_NO_APPL_RECOVERY_NEEDED_get, Swig_var_ApplLevelRecoveryIndicator_NO_APPL_RECOVERY_NEEDED_set);
  SWIG_addvarlink(globals, "ApplLevelRecoveryIndicator_APPL_RECOVERY_NEEDED", Swig_var_ApplLevelRecoveryIndicator_APPL_RECOVERY_NEEDED_get, Swig_var_ApplLevelRecoveryIndicator_APPL_RECOVERY_NEEDED_set);
  SWIG_addvarlink(globals, "RiskLimitRequestType_DEFINITIONS", Swig_var_RiskLimitRequestType_DEFINITIONS_get, Swig_var_RiskLimitRequestType_DEFINITIONS_set);
  SWIG_addvarlink(globals, "RiskLimitRequestType_UTILIZATION", Swig_var_RiskLimitRequestType_UTILIZATION_get, Swig_var_RiskLimitRequestType_UTILIZATION_set);
  SWIG_addvarlink(globals, "RiskLimitRequestType_DEFINITIONS_AND_UTILIZATIONS", Swig_var_RiskLimitRequestType_DEFINITIONS_AND_UTILIZATIONS_get, Swig_var_RiskLimitRequestType_DEFINITIONS_AND_UTILIZATIONS_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_SUCCESSFUL", Swig_var_RiskLimitRequestResult_SUCCESSFUL_get, Swig_var_RiskLimitRequestResult_SUCCESSFUL_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_INVALID_PARTY", Swig_var_RiskLimitRequestResult_INVALID_PARTY_get, Swig_var_RiskLimitRequestResult_INVALID_PARTY_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_INVALID_RELATED_PARTY", Swig_var_RiskLimitRequestResult_INVALID_RELATED_PARTY_get, Swig_var_RiskLimitRequestResult_INVALID_RELATED_PARTY_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_INVALID_RISK_LIMIT_TYPE", Swig_var_RiskLimitRequestResult_INVALID_RISK_LIMIT_TYPE_get, Swig_var_RiskLimitRequestResult_INVALID_RISK_LIMIT_TYPE_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_INVALID_RISK_LIMIT_ID", Swig_var_RiskLimitRequestResult_INVALID_RISK_LIMIT_ID_get, Swig_var_RiskLimitRequestResult_INVALID_RISK_LIMIT_ID_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_INVALID_RISK_LIMIT_AMOUNT", Swig_var_RiskLimitRequestResult_INVALID_RISK_LIMIT_AMOUNT_get, Swig_var_RiskLimitRequestResult_INVALID_RISK_LIMIT_AMOUNT_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_INVALID_RISK_WARNING_LEVEL_ACTION", Swig_var_RiskLimitRequestResult_INVALID_RISK_WARNING_LEVEL_ACTION_get, Swig_var_RiskLimitRequestResult_INVALID_RISK_WARNING_LEVEL_ACTION_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_INVALID_RISK_INSTRUMENT_SCOPE", Swig_var_RiskLimitRequestResult_INVALID_RISK_INSTRUMENT_SCOPE_get, Swig_var_RiskLimitRequestResult_INVALID_RISK_INSTRUMENT_SCOPE_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_RISK_LIMIT_ACTIONS_NOT_SUPPORTED", Swig_var_RiskLimitRequestResult_RISK_LIMIT_ACTIONS_NOT_SUPPORTED_get, Swig_var_RiskLimitRequestResult_RISK_LIMIT_ACTIONS_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_WARNING_LEVELS_NOT_SUPPORTED", Swig_var_RiskLimitRequestResult_WARNING_LEVELS_NOT_SUPPORTED_get, Swig_var_RiskLimitRequestResult_WARNING_LEVELS_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_WARNING_LEVEL_ACTIONS_NOT_SUPPORTED", Swig_var_RiskLimitRequestResult_WARNING_LEVEL_ACTIONS_NOT_SUPPORTED_get, Swig_var_RiskLimitRequestResult_WARNING_LEVEL_ACTIONS_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_RISK_INSTRUMENT_SCOPE_NOT_SUPPORTED", Swig_var_RiskLimitRequestResult_RISK_INSTRUMENT_SCOPE_NOT_SUPPORTED_get, Swig_var_RiskLimitRequestResult_RISK_INSTRUMENT_SCOPE_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_RISK_LIMIT_NOT_APPROVED_FOR_PARTY", Swig_var_RiskLimitRequestResult_RISK_LIMIT_NOT_APPROVED_FOR_PARTY_get, Swig_var_RiskLimitRequestResult_RISK_LIMIT_NOT_APPROVED_FOR_PARTY_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_RISK_LIMIT_ALREADY_DEFINED_FOR_PARTY", Swig_var_RiskLimitRequestResult_RISK_LIMIT_ALREADY_DEFINED_FOR_PARTY_get, Swig_var_RiskLimitRequestResult_RISK_LIMIT_ALREADY_DEFINED_FOR_PARTY_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_INSTRUMENT_NOT_APPROVED_FOR_PARTY", Swig_var_RiskLimitRequestResult_INSTRUMENT_NOT_APPROVED_FOR_PARTY_get, Swig_var_RiskLimitRequestResult_INSTRUMENT_NOT_APPROVED_FOR_PARTY_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_NOT_AUTHORIZED", Swig_var_RiskLimitRequestResult_NOT_AUTHORIZED_get, Swig_var_RiskLimitRequestResult_NOT_AUTHORIZED_set);
  SWIG_addvarlink(globals, "RiskLimitRequestResult_OTHER", Swig_var_RiskLimitRequestResult_OTHER_get, Swig_var_RiskLimitRequestResult_OTHER_set);
  SWIG_addvarlink(globals, "RiskLimitAction_QUEUE_INBOUND", Swig_var_RiskLimitAction_QUEUE_INBOUND_get, Swig_var_RiskLimitAction_QUEUE_INBOUND_set);
  SWIG_addvarlink(globals, "RiskLimitAction_QUEUE_OUTBOUND", Swig_var_RiskLimitAction_QUEUE_OUTBOUND_get, Swig_var_RiskLimitAction_QUEUE_OUTBOUND_set);
  SWIG_addvarlink(globals, "RiskLimitAction_REJECT", Swig_var_RiskLimitAction_REJECT_get, Swig_var_RiskLimitAction_REJECT_set);
  SWIG_addvarlink(globals, "RiskLimitAction_DISCONNECT", Swig_var_RiskLimitAction_DISCONNECT_get, Swig_var_RiskLimitAction_DISCONNECT_set);
  SWIG_addvarlink(globals, "RiskLimitAction_WARNING", Swig_var_RiskLimitAction_WARNING_get, Swig_var_RiskLimitAction_WARNING_set);
  SWIG_addvarlink(globals, "RiskLimitAction_PING_CREDIT_CHECK_WITH_REVALIDATION", Swig_var_RiskLimitAction_PING_CREDIT_CHECK_WITH_REVALIDATION_get, Swig_var_RiskLimitAction_PING_CREDIT_CHECK_WITH_REVALIDATION_set);
  SWIG_addvarlink(globals, "RiskLimitAction_PING_CREDIT_CHECK_NO_REVALIDATION", Swig_var_RiskLimitAction_PING_CREDIT_CHECK_NO_REVALIDATION_get, Swig_var_RiskLimitAction_PING_CREDIT_CHECK_NO_REVALIDATION_set);
  SWIG_addvarlink(globals, "RiskLimitAction_PUSH_CREDIT_CHECK_WITH_REVALIDATION", Swig_var_RiskLimitAction_PUSH_CREDIT_CHECK_WITH_REVALIDATION_get, Swig_var_RiskLimitAction_PUSH_CREDIT_CHECK_WITH_REVALIDATION_set);
  SWIG_addvarlink(globals, "RiskLimitAction_PUSH_CREDIT_CHECK_NO_REVALIDATION", Swig_var_RiskLimitAction_PUSH_CREDIT_CHECK_NO_REVALIDATION_get, Swig_var_RiskLimitAction_PUSH_CREDIT_CHECK_NO_REVALIDATION_set);
  SWIG_addvarlink(globals, "RiskLimitAction_SUSPEND", Swig_var_RiskLimitAction_SUSPEND_get, Swig_var_RiskLimitAction_SUSPEND_set);
  SWIG_addvarlink(globals, "RiskLimitAction_HALT_TRADING", Swig_var_RiskLimitAction_HALT_TRADING_get, Swig_var_RiskLimitAction_HALT_TRADING_set);
  SWIG_addvarlink(globals, "EntitlementType_TRADE", Swig_var_EntitlementType_TRADE_get, Swig_var_EntitlementType_TRADE_set);
  SWIG_addvarlink(globals, "EntitlementType_MAKE_MARKETS", Swig_var_EntitlementType_MAKE_MARKETS_get, Swig_var_EntitlementType_MAKE_MARKETS_set);
  SWIG_addvarlink(globals, "EntitlementType_HOLD_POSITIONS", Swig_var_EntitlementType_HOLD_POSITIONS_get, Swig_var_EntitlementType_HOLD_POSITIONS_set);
  SWIG_addvarlink(globals, "EntitlementType_PERFORM_GIVE_UPS", Swig_var_EntitlementType_PERFORM_GIVE_UPS_get, Swig_var_EntitlementType_PERFORM_GIVE_UPS_set);
  SWIG_addvarlink(globals, "EntitlementType_SUBMIT_IO_IS", Swig_var_EntitlementType_SUBMIT_IO_IS_get, Swig_var_EntitlementType_SUBMIT_IO_IS_set);
  SWIG_addvarlink(globals, "EntitlementType_SUBSCRIBE_MARKET_DATA", Swig_var_EntitlementType_SUBSCRIBE_MARKET_DATA_get, Swig_var_EntitlementType_SUBSCRIBE_MARKET_DATA_set);
  SWIG_addvarlink(globals, "EntitlementType_SHORT_WITH_PRE_BORROW", Swig_var_EntitlementType_SHORT_WITH_PRE_BORROW_get, Swig_var_EntitlementType_SHORT_WITH_PRE_BORROW_set);
  SWIG_addvarlink(globals, "EntitlementType_SUBMIT_QUOTE_REQUESTS", Swig_var_EntitlementType_SUBMIT_QUOTE_REQUESTS_get, Swig_var_EntitlementType_SUBMIT_QUOTE_REQUESTS_set);
  SWIG_addvarlink(globals, "EntitlementType_RESPOND_TO_QUOTE_REQUESTS", Swig_var_EntitlementType_RESPOND_TO_QUOTE_REQUESTS_get, Swig_var_EntitlementType_RESPOND_TO_QUOTE_REQUESTS_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_TENOR", Swig_var_EntitlementAttribDatatype_TENOR_get, Swig_var_EntitlementAttribDatatype_TENOR_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_PATTERN", Swig_var_EntitlementAttribDatatype_PATTERN_get, Swig_var_EntitlementAttribDatatype_PATTERN_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_RESERVED100_PLUS", Swig_var_EntitlementAttribDatatype_RESERVED100_PLUS_get, Swig_var_EntitlementAttribDatatype_RESERVED100_PLUS_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_RESERVED1000_PLUS", Swig_var_EntitlementAttribDatatype_RESERVED1000_PLUS_get, Swig_var_EntitlementAttribDatatype_RESERVED1000_PLUS_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_RESERVED4000_PLUS", Swig_var_EntitlementAttribDatatype_RESERVED4000_PLUS_get, Swig_var_EntitlementAttribDatatype_RESERVED4000_PLUS_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_STRING", Swig_var_EntitlementAttribDatatype_STRING_get, Swig_var_EntitlementAttribDatatype_STRING_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_MULTIPLE_CHAR_VALUE", Swig_var_EntitlementAttribDatatype_MULTIPLE_CHAR_VALUE_get, Swig_var_EntitlementAttribDatatype_MULTIPLE_CHAR_VALUE_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_CURRENCY", Swig_var_EntitlementAttribDatatype_CURRENCY_get, Swig_var_EntitlementAttribDatatype_CURRENCY_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_EXCHANGE", Swig_var_EntitlementAttribDatatype_EXCHANGE_get, Swig_var_EntitlementAttribDatatype_EXCHANGE_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_MONTH_YEAR", Swig_var_EntitlementAttribDatatype_MONTH_YEAR_get, Swig_var_EntitlementAttribDatatype_MONTH_YEAR_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_UTC_TIMESTAMP", Swig_var_EntitlementAttribDatatype_UTC_TIMESTAMP_get, Swig_var_EntitlementAttribDatatype_UTC_TIMESTAMP_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_UTC_TIME_ONLY", Swig_var_EntitlementAttribDatatype_UTC_TIME_ONLY_get, Swig_var_EntitlementAttribDatatype_UTC_TIME_ONLY_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_LOCAL_MKT_DATE", Swig_var_EntitlementAttribDatatype_LOCAL_MKT_DATE_get, Swig_var_EntitlementAttribDatatype_LOCAL_MKT_DATE_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_UTC_DATE_ONLY", Swig_var_EntitlementAttribDatatype_UTC_DATE_ONLY_get, Swig_var_EntitlementAttribDatatype_UTC_DATE_ONLY_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_DATA", Swig_var_EntitlementAttribDatatype_DATA_get, Swig_var_EntitlementAttribDatatype_DATA_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_MULTIPLE_STRING_VALUE", Swig_var_EntitlementAttribDatatype_MULTIPLE_STRING_VALUE_get, Swig_var_EntitlementAttribDatatype_MULTIPLE_STRING_VALUE_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_COUNTRY", Swig_var_EntitlementAttribDatatype_COUNTRY_get, Swig_var_EntitlementAttribDatatype_COUNTRY_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_LANGUAGE", Swig_var_EntitlementAttribDatatype_LANGUAGE_get, Swig_var_EntitlementAttribDatatype_LANGUAGE_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_TZ_TIME_ONLY", Swig_var_EntitlementAttribDatatype_TZ_TIME_ONLY_get, Swig_var_EntitlementAttribDatatype_TZ_TIME_ONLY_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_TZ_TIMESTAMP", Swig_var_EntitlementAttribDatatype_TZ_TIMESTAMP_get, Swig_var_EntitlementAttribDatatype_TZ_TIMESTAMP_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_XML_DATA", Swig_var_EntitlementAttribDatatype_XML_DATA_get, Swig_var_EntitlementAttribDatatype_XML_DATA_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_CHAR", Swig_var_EntitlementAttribDatatype_CHAR_get, Swig_var_EntitlementAttribDatatype_CHAR_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_BOOLEAN", Swig_var_EntitlementAttribDatatype_BOOLEAN_get, Swig_var_EntitlementAttribDatatype_BOOLEAN_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_FLOAT", Swig_var_EntitlementAttribDatatype_FLOAT_get, Swig_var_EntitlementAttribDatatype_FLOAT_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_QTY", Swig_var_EntitlementAttribDatatype_QTY_get, Swig_var_EntitlementAttribDatatype_QTY_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_PRICE", Swig_var_EntitlementAttribDatatype_PRICE_get, Swig_var_EntitlementAttribDatatype_PRICE_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_PRICE_OFFSET", Swig_var_EntitlementAttribDatatype_PRICE_OFFSET_get, Swig_var_EntitlementAttribDatatype_PRICE_OFFSET_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_AMT", Swig_var_EntitlementAttribDatatype_AMT_get, Swig_var_EntitlementAttribDatatype_AMT_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_PERCENTAGE", Swig_var_EntitlementAttribDatatype_PERCENTAGE_get, Swig_var_EntitlementAttribDatatype_PERCENTAGE_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_INT", Swig_var_EntitlementAttribDatatype_INT_get, Swig_var_EntitlementAttribDatatype_INT_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_LENGTH", Swig_var_EntitlementAttribDatatype_LENGTH_get, Swig_var_EntitlementAttribDatatype_LENGTH_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_NUM_IN_GROUP", Swig_var_EntitlementAttribDatatype_NUM_IN_GROUP_get, Swig_var_EntitlementAttribDatatype_NUM_IN_GROUP_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_SEQ_NUM", Swig_var_EntitlementAttribDatatype_SEQ_NUM_get, Swig_var_EntitlementAttribDatatype_SEQ_NUM_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_TAG_NUM", Swig_var_EntitlementAttribDatatype_TAG_NUM_get, Swig_var_EntitlementAttribDatatype_TAG_NUM_set);
  SWIG_addvarlink(globals, "EntitlementAttribDatatype_DAY_OF_MONTH", Swig_var_EntitlementAttribDatatype_DAY_OF_MONTH_get, Swig_var_EntitlementAttribDatatype_DAY_OF_MONTH_set);
  SWIG_addvarlink(globals, "TradSesControl_AUTOMATIC", Swig_var_TradSesControl_AUTOMATIC_get, Swig_var_TradSesControl_AUTOMATIC_set);
  SWIG_addvarlink(globals, "TradSesControl_MANUAL", Swig_var_TradSesControl_MANUAL_get, Swig_var_TradSesControl_MANUAL_set);
  SWIG_addvarlink(globals, "TradeVolType_NUMBER_OF_UNITS", Swig_var_TradeVolType_NUMBER_OF_UNITS_get, Swig_var_TradeVolType_NUMBER_OF_UNITS_set);
  SWIG_addvarlink(globals, "TradeVolType_NUMBER_OF_ROUND_LOTS", Swig_var_TradeVolType_NUMBER_OF_ROUND_LOTS_get, Swig_var_TradeVolType_NUMBER_OF_ROUND_LOTS_set);
  SWIG_addvarlink(globals, "OrderEventType_ADDED", Swig_var_OrderEventType_ADDED_get, Swig_var_OrderEventType_ADDED_set);
  SWIG_addvarlink(globals, "OrderEventType_MODIFIED", Swig_var_OrderEventType_MODIFIED_get, Swig_var_OrderEventType_MODIFIED_set);
  SWIG_addvarlink(globals, "OrderEventType_DELETED", Swig_var_OrderEventType_DELETED_get, Swig_var_OrderEventType_DELETED_set);
  SWIG_addvarlink(globals, "OrderEventType_PARTIALLY_FILLED", Swig_var_OrderEventType_PARTIALLY_FILLED_get, Swig_var_OrderEventType_PARTIALLY_FILLED_set);
  SWIG_addvarlink(globals, "OrderEventType_FILLED", Swig_var_OrderEventType_FILLED_get, Swig_var_OrderEventType_FILLED_set);
  SWIG_addvarlink(globals, "OrderEventType_SUSPENDED", Swig_var_OrderEventType_SUSPENDED_get, Swig_var_OrderEventType_SUSPENDED_set);
  SWIG_addvarlink(globals, "OrderEventType_RELEASED", Swig_var_OrderEventType_RELEASED_get, Swig_var_OrderEventType_RELEASED_set);
  SWIG_addvarlink(globals, "OrderEventType_RESTATED", Swig_var_OrderEventType_RESTATED_get, Swig_var_OrderEventType_RESTATED_set);
  SWIG_addvarlink(globals, "OrderEventType_LOCKED", Swig_var_OrderEventType_LOCKED_get, Swig_var_OrderEventType_LOCKED_set);
  SWIG_addvarlink(globals, "OrderEventType_TRIGGERED", Swig_var_OrderEventType_TRIGGERED_get, Swig_var_OrderEventType_TRIGGERED_set);
  SWIG_addvarlink(globals, "OrderEventType_ACTIVATED", Swig_var_OrderEventType_ACTIVATED_get, Swig_var_OrderEventType_ACTIVATED_set);
  SWIG_addvarlink(globals, "OrderEventReason_ADD_ORDER_REQUEST", Swig_var_OrderEventReason_ADD_ORDER_REQUEST_get, Swig_var_OrderEventReason_ADD_ORDER_REQUEST_set);
  SWIG_addvarlink(globals, "OrderEventReason_MODIFY_ORDER_REQUEST", Swig_var_OrderEventReason_MODIFY_ORDER_REQUEST_get, Swig_var_OrderEventReason_MODIFY_ORDER_REQUEST_set);
  SWIG_addvarlink(globals, "OrderEventReason_DELETE_ORDER_REQUEST", Swig_var_OrderEventReason_DELETE_ORDER_REQUEST_get, Swig_var_OrderEventReason_DELETE_ORDER_REQUEST_set);
  SWIG_addvarlink(globals, "OrderEventReason_ORDER_ENTERED_OOB", Swig_var_OrderEventReason_ORDER_ENTERED_OOB_get, Swig_var_OrderEventReason_ORDER_ENTERED_OOB_set);
  SWIG_addvarlink(globals, "OrderEventReason_ORDER_MODIFIED_OOB", Swig_var_OrderEventReason_ORDER_MODIFIED_OOB_get, Swig_var_OrderEventReason_ORDER_MODIFIED_OOB_set);
  SWIG_addvarlink(globals, "OrderEventReason_ORDER_DELETED_OOB", Swig_var_OrderEventReason_ORDER_DELETED_OOB_get, Swig_var_OrderEventReason_ORDER_DELETED_OOB_set);
  SWIG_addvarlink(globals, "OrderEventReason_ORDER_ACTIVATED_OR_TRIGGERED", Swig_var_OrderEventReason_ORDER_ACTIVATED_OR_TRIGGERED_get, Swig_var_OrderEventReason_ORDER_ACTIVATED_OR_TRIGGERED_set);
  SWIG_addvarlink(globals, "OrderEventReason_ORDER_EXPIRED", Swig_var_OrderEventReason_ORDER_EXPIRED_get, Swig_var_OrderEventReason_ORDER_EXPIRED_set);
  SWIG_addvarlink(globals, "OrderEventReason_RESERVE_ORDER_REFRESHED", Swig_var_OrderEventReason_RESERVE_ORDER_REFRESHED_get, Swig_var_OrderEventReason_RESERVE_ORDER_REFRESHED_set);
  SWIG_addvarlink(globals, "OrderEventReason_AWAY_MARKET_BETTER", Swig_var_OrderEventReason_AWAY_MARKET_BETTER_get, Swig_var_OrderEventReason_AWAY_MARKET_BETTER_set);
  SWIG_addvarlink(globals, "OrderEventReason_CORPORATE_ACTION", Swig_var_OrderEventReason_CORPORATE_ACTION_get, Swig_var_OrderEventReason_CORPORATE_ACTION_set);
  SWIG_addvarlink(globals, "OrderEventReason_START_OF_DAY", Swig_var_OrderEventReason_START_OF_DAY_get, Swig_var_OrderEventReason_START_OF_DAY_set);
  SWIG_addvarlink(globals, "OrderEventReason_END_OF_DAY", Swig_var_OrderEventReason_END_OF_DAY_get, Swig_var_OrderEventReason_END_OF_DAY_set);
  SWIG_addvarlink(globals, "AuctionType_NONE", Swig_var_AuctionType_NONE_get, Swig_var_AuctionType_NONE_set);
  SWIG_addvarlink(globals, "AuctionType_BLOCK_ORDER_AUCTION", Swig_var_AuctionType_BLOCK_ORDER_AUCTION_get, Swig_var_AuctionType_BLOCK_ORDER_AUCTION_set);
  SWIG_addvarlink(globals, "AuctionType_DIRECTED_ORDER_AUCTION", Swig_var_AuctionType_DIRECTED_ORDER_AUCTION_get, Swig_var_AuctionType_DIRECTED_ORDER_AUCTION_set);
  SWIG_addvarlink(globals, "AuctionType_EXPOSURE_ORDER_AUCTION", Swig_var_AuctionType_EXPOSURE_ORDER_AUCTION_get, Swig_var_AuctionType_EXPOSURE_ORDER_AUCTION_set);
  SWIG_addvarlink(globals, "AuctionType_FLASH_ORDER_AUCTION", Swig_var_AuctionType_FLASH_ORDER_AUCTION_get, Swig_var_AuctionType_FLASH_ORDER_AUCTION_set);
  SWIG_addvarlink(globals, "AuctionType_FACILITATION_ORDER_AUCTION", Swig_var_AuctionType_FACILITATION_ORDER_AUCTION_get, Swig_var_AuctionType_FACILITATION_ORDER_AUCTION_set);
  SWIG_addvarlink(globals, "AuctionType_SOLICITATION_ORDER_AUCTION", Swig_var_AuctionType_SOLICITATION_ORDER_AUCTION_get, Swig_var_AuctionType_SOLICITATION_ORDER_AUCTION_set);
  SWIG_addvarlink(globals, "AuctionType_PRICE_IMPROVEMENT_MECHANISM", Swig_var_AuctionType_PRICE_IMPROVEMENT_MECHANISM_get, Swig_var_AuctionType_PRICE_IMPROVEMENT_MECHANISM_set);
  SWIG_addvarlink(globals, "AuctionType_DIRECTED_ORDER_PRICE_IMPROVEMENT_MECHANISM", Swig_var_AuctionType_DIRECTED_ORDER_PRICE_IMPROVEMENT_MECHANISM_get, Swig_var_AuctionType_DIRECTED_ORDER_PRICE_IMPROVEMENT_MECHANISM_set);
  SWIG_addvarlink(globals, "AuctionInstruction_AUTOMATED_AUCTION_PERMITTED", Swig_var_AuctionInstruction_AUTOMATED_AUCTION_PERMITTED_get, Swig_var_AuctionInstruction_AUTOMATED_AUCTION_PERMITTED_set);
  SWIG_addvarlink(globals, "AuctionInstruction_AUTOMATED_AUCTION_NOT_PERMITTED", Swig_var_AuctionInstruction_AUTOMATED_AUCTION_NOT_PERMITTED_get, Swig_var_AuctionInstruction_AUTOMATED_AUCTION_NOT_PERMITTED_set);
  SWIG_addvarlink(globals, "LockType_NOT_LOCKED", Swig_var_LockType_NOT_LOCKED_get, Swig_var_LockType_NOT_LOCKED_set);
  SWIG_addvarlink(globals, "LockType_AWAY_MARKET_NETTER", Swig_var_LockType_AWAY_MARKET_NETTER_get, Swig_var_LockType_AWAY_MARKET_NETTER_set);
  SWIG_addvarlink(globals, "LockType_THREE_TICK_LOCKED", Swig_var_LockType_THREE_TICK_LOCKED_get, Swig_var_LockType_THREE_TICK_LOCKED_set);
  SWIG_addvarlink(globals, "LockType_LOCKED_BY_MARKET_MAKER", Swig_var_LockType_LOCKED_BY_MARKET_MAKER_get, Swig_var_LockType_LOCKED_BY_MARKET_MAKER_set);
  SWIG_addvarlink(globals, "LockType_DIRECTED_ORDER_LOCK", Swig_var_LockType_DIRECTED_ORDER_LOCK_get, Swig_var_LockType_DIRECTED_ORDER_LOCK_set);
  SWIG_addvarlink(globals, "LockType_MULTILEG_LOCK", Swig_var_LockType_MULTILEG_LOCK_get, Swig_var_LockType_MULTILEG_LOCK_set);
  SWIG_addvarlink(globals, "LockType_MARKET_ORDER_LOCK", Swig_var_LockType_MARKET_ORDER_LOCK_get, Swig_var_LockType_MARKET_ORDER_LOCK_set);
  SWIG_addvarlink(globals, "LockType_PRE_ASSIGNMENT_LOCK", Swig_var_LockType_PRE_ASSIGNMENT_LOCK_get, Swig_var_LockType_PRE_ASSIGNMENT_LOCK_set);
  SWIG_addvarlink(globals, "ReleaseInstruction_ISO", Swig_var_ReleaseInstruction_ISO_get, Swig_var_ReleaseInstruction_ISO_set);
  SWIG_addvarlink(globals, "ReleaseInstruction_NO_AWAY_MARKET_BETTER_CHECK", Swig_var_ReleaseInstruction_NO_AWAY_MARKET_BETTER_CHECK_get, Swig_var_ReleaseInstruction_NO_AWAY_MARKET_BETTER_CHECK_set);
  SWIG_addvarlink(globals, "DisclosureType_VOLUME", Swig_var_DisclosureType_VOLUME_get, Swig_var_DisclosureType_VOLUME_set);
  SWIG_addvarlink(globals, "DisclosureType_PRICE", Swig_var_DisclosureType_PRICE_get, Swig_var_DisclosureType_PRICE_set);
  SWIG_addvarlink(globals, "DisclosureType_SIDE", Swig_var_DisclosureType_SIDE_get, Swig_var_DisclosureType_SIDE_set);
  SWIG_addvarlink(globals, "DisclosureType_AON", Swig_var_DisclosureType_AON_get, Swig_var_DisclosureType_AON_set);
  SWIG_addvarlink(globals, "DisclosureType_GENERAL", Swig_var_DisclosureType_GENERAL_get, Swig_var_DisclosureType_GENERAL_set);
  SWIG_addvarlink(globals, "DisclosureType_CLEARING_ACCOUNT", Swig_var_DisclosureType_CLEARING_ACCOUNT_get, Swig_var_DisclosureType_CLEARING_ACCOUNT_set);
  SWIG_addvarlink(globals, "DisclosureType_CMTA_ACCOUNT", Swig_var_DisclosureType_CMTA_ACCOUNT_get, Swig_var_DisclosureType_CMTA_ACCOUNT_set);
  SWIG_addvarlink(globals, "DisclosureInstruction_NO", Swig_var_DisclosureInstruction_NO_get, Swig_var_DisclosureInstruction_NO_set);
  SWIG_addvarlink(globals, "DisclosureInstruction_YES", Swig_var_DisclosureInstruction_YES_get, Swig_var_DisclosureInstruction_YES_set);
  SWIG_addvarlink(globals, "DisclosureInstruction_USE_DEFAULT_SETTING", Swig_var_DisclosureInstruction_USE_DEFAULT_SETTING_get, Swig_var_DisclosureInstruction_USE_DEFAULT_SETTING_set);
  SWIG_addvarlink(globals, "TradingCapacity_CUSTOMER", Swig_var_TradingCapacity_CUSTOMER_get, Swig_var_TradingCapacity_CUSTOMER_set);
  SWIG_addvarlink(globals, "TradingCapacity_CUSTOMER_PROFESSIONAL", Swig_var_TradingCapacity_CUSTOMER_PROFESSIONAL_get, Swig_var_TradingCapacity_CUSTOMER_PROFESSIONAL_set);
  SWIG_addvarlink(globals, "TradingCapacity_BROKER_DEALER", Swig_var_TradingCapacity_BROKER_DEALER_get, Swig_var_TradingCapacity_BROKER_DEALER_set);
  SWIG_addvarlink(globals, "TradingCapacity_CUSTOMER_BROKER_DEALER", Swig_var_TradingCapacity_CUSTOMER_BROKER_DEALER_get, Swig_var_TradingCapacity_CUSTOMER_BROKER_DEALER_set);
  SWIG_addvarlink(globals, "TradingCapacity_PRINCIPAL", Swig_var_TradingCapacity_PRINCIPAL_get, Swig_var_TradingCapacity_PRINCIPAL_set);
  SWIG_addvarlink(globals, "TradingCapacity_MARKET_MAKER", Swig_var_TradingCapacity_MARKET_MAKER_get, Swig_var_TradingCapacity_MARKET_MAKER_set);
  SWIG_addvarlink(globals, "TradingCapacity_AWAY_MARKET_MAKER", Swig_var_TradingCapacity_AWAY_MARKET_MAKER_get, Swig_var_TradingCapacity_AWAY_MARKET_MAKER_set);
  SWIG_addvarlink(globals, "TradingCapacity_SYSTEMATIC_INTERNALISER", Swig_var_TradingCapacity_SYSTEMATIC_INTERNALISER_get, Swig_var_TradingCapacity_SYSTEMATIC_INTERNALISER_set);
  SWIG_addvarlink(globals, "ClearingAccountType_CUSTOMER", Swig_var_ClearingAccountType_CUSTOMER_get, Swig_var_ClearingAccountType_CUSTOMER_set);
  SWIG_addvarlink(globals, "ClearingAccountType_FIRM", Swig_var_ClearingAccountType_FIRM_get, Swig_var_ClearingAccountType_FIRM_set);
  SWIG_addvarlink(globals, "ClearingAccountType_MARKET_MAKER", Swig_var_ClearingAccountType_MARKET_MAKER_get, Swig_var_ClearingAccountType_MARKET_MAKER_set);
  SWIG_addvarlink(globals, "RelatedPriceSource_NB_BID", Swig_var_RelatedPriceSource_NB_BID_get, Swig_var_RelatedPriceSource_NB_BID_set);
  SWIG_addvarlink(globals, "RelatedPriceSource_NB_OFFER", Swig_var_RelatedPriceSource_NB_OFFER_get, Swig_var_RelatedPriceSource_NB_OFFER_set);
  SWIG_addvarlink(globals, "MinQtyMethod_ONCE", Swig_var_MinQtyMethod_ONCE_get, Swig_var_MinQtyMethod_ONCE_set);
  SWIG_addvarlink(globals, "MinQtyMethod_MULTIPLE", Swig_var_MinQtyMethod_MULTIPLE_get, Swig_var_MinQtyMethod_MULTIPLE_set);
  SWIG_addvarlink(globals, "Triggered_NOT_TRIGGERED", Swig_var_Triggered_NOT_TRIGGERED_get, Swig_var_Triggered_NOT_TRIGGERED_set);
  SWIG_addvarlink(globals, "Triggered_TRIGGERED", Swig_var_Triggered_TRIGGERED_get, Swig_var_Triggered_TRIGGERED_set);
  SWIG_addvarlink(globals, "Triggered_STOP_ORDER_TRIGGERED", Swig_var_Triggered_STOP_ORDER_TRIGGERED_get, Swig_var_Triggered_STOP_ORDER_TRIGGERED_set);
  SWIG_addvarlink(globals, "Triggered_OCO_ORDER_TRIGGERED", Swig_var_Triggered_OCO_ORDER_TRIGGERED_get, Swig_var_Triggered_OCO_ORDER_TRIGGERED_set);
  SWIG_addvarlink(globals, "Triggered_OTO_ORDER_TRIGGERED", Swig_var_Triggered_OTO_ORDER_TRIGGERED_get, Swig_var_Triggered_OTO_ORDER_TRIGGERED_set);
  SWIG_addvarlink(globals, "Triggered_OUO_ORDER_TRIGGERED", Swig_var_Triggered_OUO_ORDER_TRIGGERED_get, Swig_var_Triggered_OUO_ORDER_TRIGGERED_set);
  SWIG_addvarlink(globals, "EventTimeUnit_HOUR", Swig_var_EventTimeUnit_HOUR_get, Swig_var_EventTimeUnit_HOUR_set);
  SWIG_addvarlink(globals, "EventTimeUnit_MINUTE", Swig_var_EventTimeUnit_MINUTE_get, Swig_var_EventTimeUnit_MINUTE_set);
  SWIG_addvarlink(globals, "EventTimeUnit_SECOND", Swig_var_EventTimeUnit_SECOND_get, Swig_var_EventTimeUnit_SECOND_set);
  SWIG_addvarlink(globals, "EventTimeUnit_DAY", Swig_var_EventTimeUnit_DAY_get, Swig_var_EventTimeUnit_DAY_set);
  SWIG_addvarlink(globals, "EventTimeUnit_WEEK", Swig_var_EventTimeUnit_WEEK_get, Swig_var_EventTimeUnit_WEEK_set);
  SWIG_addvarlink(globals, "EventTimeUnit_MONTH", Swig_var_EventTimeUnit_MONTH_get, Swig_var_EventTimeUnit_MONTH_set);
  SWIG_addvarlink(globals, "EventTimeUnit_YEAR", Swig_var_EventTimeUnit_YEAR_get, Swig_var_EventTimeUnit_YEAR_set);
  SWIG_addvarlink(globals, "OrderOrigination_ORDER_RECEIVED_FROM_CUSTOMER", Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_CUSTOMER_get, Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_CUSTOMER_set);
  SWIG_addvarlink(globals, "OrderOrigination_ORDER_RECEIVED_FROM_WITHIN_FIRM", Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_WITHIN_FIRM_get, Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_WITHIN_FIRM_set);
  SWIG_addvarlink(globals, "OrderOrigination_ORDER_RECEIVED_FROM_ANOTHER_BROKER_DEALER", Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_ANOTHER_BROKER_DEALER_get, Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_ANOTHER_BROKER_DEALER_set);
  SWIG_addvarlink(globals, "OrderOrigination_ORDER_RECEIVED_FROM_CUSTOMER_OR_WITH_FIRM", Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_CUSTOMER_OR_WITH_FIRM_get, Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_CUSTOMER_OR_WITH_FIRM_set);
  SWIG_addvarlink(globals, "OrderOrigination_ORDER_RECEIVED_FROM_DIRECT_ACCESS_CUSTOMER", Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_DIRECT_ACCESS_CUSTOMER_get, Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_DIRECT_ACCESS_CUSTOMER_set);
  SWIG_addvarlink(globals, "OrderOrigination_ORDER_RECEIVED_FROM_FOREIGN_DEALER_EQUIVALENT", Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_FOREIGN_DEALER_EQUIVALENT_get, Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_FOREIGN_DEALER_EQUIVALENT_set);
  SWIG_addvarlink(globals, "OrderOrigination_ORDER_RECEIVED_FROM_EXECUTION_ONLY_SERVICE", Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_EXECUTION_ONLY_SERVICE_get, Swig_var_OrderOrigination_ORDER_RECEIVED_FROM_EXECUTION_ONLY_SERVICE_set);
  SWIG_addvarlink(globals, "ClearedIndicator_NOT_CLEARED", Swig_var_ClearedIndicator_NOT_CLEARED_get, Swig_var_ClearedIndicator_NOT_CLEARED_set);
  SWIG_addvarlink(globals, "ClearedIndicator_CLEARED", Swig_var_ClearedIndicator_CLEARED_get, Swig_var_ClearedIndicator_CLEARED_set);
  SWIG_addvarlink(globals, "ClearedIndicator_SUBMITTED", Swig_var_ClearedIndicator_SUBMITTED_get, Swig_var_ClearedIndicator_SUBMITTED_set);
  SWIG_addvarlink(globals, "ClearedIndicator_REJECTED", Swig_var_ClearedIndicator_REJECTED_get, Swig_var_ClearedIndicator_REJECTED_set);
  SWIG_addvarlink(globals, "ContractRefPosType_TWO_COMPONENT_INTERCOMMODITY_SPREAD", Swig_var_ContractRefPosType_TWO_COMPONENT_INTERCOMMODITY_SPREAD_get, Swig_var_ContractRefPosType_TWO_COMPONENT_INTERCOMMODITY_SPREAD_set);
  SWIG_addvarlink(globals, "ContractRefPosType_INDEX_OR_BASKET", Swig_var_ContractRefPosType_INDEX_OR_BASKET_get, Swig_var_ContractRefPosType_INDEX_OR_BASKET_set);
  SWIG_addvarlink(globals, "ContractRefPosType_TWO_COMPONENT_LOCATION_BASIS", Swig_var_ContractRefPosType_TWO_COMPONENT_LOCATION_BASIS_get, Swig_var_ContractRefPosType_TWO_COMPONENT_LOCATION_BASIS_set);
  SWIG_addvarlink(globals, "ContractRefPosType_OTHER", Swig_var_ContractRefPosType_OTHER_get, Swig_var_ContractRefPosType_OTHER_set);
  SWIG_addvarlink(globals, "PositionCapacity_PRINCIPAL", Swig_var_PositionCapacity_PRINCIPAL_get, Swig_var_PositionCapacity_PRINCIPAL_set);
  SWIG_addvarlink(globals, "PositionCapacity_AGENT", Swig_var_PositionCapacity_AGENT_get, Swig_var_PositionCapacity_AGENT_set);
  SWIG_addvarlink(globals, "PositionCapacity_CUSTOMER", Swig_var_PositionCapacity_CUSTOMER_get, Swig_var_PositionCapacity_CUSTOMER_set);
  SWIG_addvarlink(globals, "PositionCapacity_COUNTERPARTY", Swig_var_PositionCapacity_COUNTERPARTY_get, Swig_var_PositionCapacity_COUNTERPARTY_set);
  SWIG_addvarlink(globals, "TradePriceCondition_SPECIAL_CUM_DIVIDEND", Swig_var_TradePriceCondition_SPECIAL_CUM_DIVIDEND_get, Swig_var_TradePriceCondition_SPECIAL_CUM_DIVIDEND_set);
  SWIG_addvarlink(globals, "TradePriceCondition_SPECIAL_CUM_RIGHTS", Swig_var_TradePriceCondition_SPECIAL_CUM_RIGHTS_get, Swig_var_TradePriceCondition_SPECIAL_CUM_RIGHTS_set);
  SWIG_addvarlink(globals, "TradePriceCondition_SPECIAL_EX_DIVIDEND", Swig_var_TradePriceCondition_SPECIAL_EX_DIVIDEND_get, Swig_var_TradePriceCondition_SPECIAL_EX_DIVIDEND_set);
  SWIG_addvarlink(globals, "TradePriceCondition_SPECIAL_EX_RIGHTS", Swig_var_TradePriceCondition_SPECIAL_EX_RIGHTS_get, Swig_var_TradePriceCondition_SPECIAL_EX_RIGHTS_set);
  SWIG_addvarlink(globals, "TradePriceCondition_SPECIAL_CUM_COUPON", Swig_var_TradePriceCondition_SPECIAL_CUM_COUPON_get, Swig_var_TradePriceCondition_SPECIAL_CUM_COUPON_set);
  SWIG_addvarlink(globals, "TradePriceCondition_SPECIAL_CUM_CAPITAL_REPAYMENTS", Swig_var_TradePriceCondition_SPECIAL_CUM_CAPITAL_REPAYMENTS_get, Swig_var_TradePriceCondition_SPECIAL_CUM_CAPITAL_REPAYMENTS_set);
  SWIG_addvarlink(globals, "TradePriceCondition_SPECIAL_EX_COUPON", Swig_var_TradePriceCondition_SPECIAL_EX_COUPON_get, Swig_var_TradePriceCondition_SPECIAL_EX_COUPON_set);
  SWIG_addvarlink(globals, "TradePriceCondition_SPECIAL_EX_CAPITAL_REPAYMENTS", Swig_var_TradePriceCondition_SPECIAL_EX_CAPITAL_REPAYMENTS_get, Swig_var_TradePriceCondition_SPECIAL_EX_CAPITAL_REPAYMENTS_set);
  SWIG_addvarlink(globals, "TradePriceCondition_CASH_SETTLEMENT", Swig_var_TradePriceCondition_CASH_SETTLEMENT_get, Swig_var_TradePriceCondition_CASH_SETTLEMENT_set);
  SWIG_addvarlink(globals, "TradePriceCondition_SPECIAL_CUM_BONUS", Swig_var_TradePriceCondition_SPECIAL_CUM_BONUS_get, Swig_var_TradePriceCondition_SPECIAL_CUM_BONUS_set);
  SWIG_addvarlink(globals, "TradePriceCondition_SPECIAL_PRICE", Swig_var_TradePriceCondition_SPECIAL_PRICE_get, Swig_var_TradePriceCondition_SPECIAL_PRICE_set);
  SWIG_addvarlink(globals, "TradePriceCondition_SPECIAL_EX_BONUS", Swig_var_TradePriceCondition_SPECIAL_EX_BONUS_get, Swig_var_TradePriceCondition_SPECIAL_EX_BONUS_set);
  SWIG_addvarlink(globals, "TradePriceCondition_GUARANTEED_DELIVERY", Swig_var_TradePriceCondition_GUARANTEED_DELIVERY_get, Swig_var_TradePriceCondition_GUARANTEED_DELIVERY_set);
  SWIG_addvarlink(globals, "TradePriceCondition_SPECIAL_DIVIDEND", Swig_var_TradePriceCondition_SPECIAL_DIVIDEND_get, Swig_var_TradePriceCondition_SPECIAL_DIVIDEND_set);
  SWIG_addvarlink(globals, "TradePriceCondition_PRICE_IMPROVEMENT", Swig_var_TradePriceCondition_PRICE_IMPROVEMENT_get, Swig_var_TradePriceCondition_PRICE_IMPROVEMENT_set);
  SWIG_addvarlink(globals, "TradePriceCondition_NON_PRICE_FORMING_TRADE", Swig_var_TradePriceCondition_NON_PRICE_FORMING_TRADE_get, Swig_var_TradePriceCondition_NON_PRICE_FORMING_TRADE_set);
  SWIG_addvarlink(globals, "TradePriceCondition_TRADE_EXEMPTED_FROM_TRADING_OBLIGATION", Swig_var_TradePriceCondition_TRADE_EXEMPTED_FROM_TRADING_OBLIGATION_get, Swig_var_TradePriceCondition_TRADE_EXEMPTED_FROM_TRADING_OBLIGATION_set);
  SWIG_addvarlink(globals, "TradePriceCondition_PRICE_PENDING", Swig_var_TradePriceCondition_PRICE_PENDING_get, Swig_var_TradePriceCondition_PRICE_PENDING_set);
  SWIG_addvarlink(globals, "TradePriceCondition_PRICE_NOT_APPLICABLE", Swig_var_TradePriceCondition_PRICE_NOT_APPLICABLE_get, Swig_var_TradePriceCondition_PRICE_NOT_APPLICABLE_set);
  SWIG_addvarlink(globals, "TradeAllocStatus_PENDING_CLEAR", Swig_var_TradeAllocStatus_PENDING_CLEAR_get, Swig_var_TradeAllocStatus_PENDING_CLEAR_set);
  SWIG_addvarlink(globals, "TradeAllocStatus_CLAIMED", Swig_var_TradeAllocStatus_CLAIMED_get, Swig_var_TradeAllocStatus_CLAIMED_set);
  SWIG_addvarlink(globals, "TradeAllocStatus_CLEARED", Swig_var_TradeAllocStatus_CLEARED_get, Swig_var_TradeAllocStatus_CLEARED_set);
  SWIG_addvarlink(globals, "TradeAllocStatus_REJECTED", Swig_var_TradeAllocStatus_REJECTED_get, Swig_var_TradeAllocStatus_REJECTED_set);
  SWIG_addvarlink(globals, "TradeQtyType_CLEARED_QUANTITY", Swig_var_TradeQtyType_CLEARED_QUANTITY_get, Swig_var_TradeQtyType_CLEARED_QUANTITY_set);
  SWIG_addvarlink(globals, "TradeQtyType_LONG_SIDE_CLAIMED_QUANTITY", Swig_var_TradeQtyType_LONG_SIDE_CLAIMED_QUANTITY_get, Swig_var_TradeQtyType_LONG_SIDE_CLAIMED_QUANTITY_set);
  SWIG_addvarlink(globals, "TradeQtyType_SHORT_SIDE_CLAIMED_QUANTITY", Swig_var_TradeQtyType_SHORT_SIDE_CLAIMED_QUANTITY_get, Swig_var_TradeQtyType_SHORT_SIDE_CLAIMED_QUANTITY_set);
  SWIG_addvarlink(globals, "TradeQtyType_LONG_SIDE_REJECTED_QUANTITY", Swig_var_TradeQtyType_LONG_SIDE_REJECTED_QUANTITY_get, Swig_var_TradeQtyType_LONG_SIDE_REJECTED_QUANTITY_set);
  SWIG_addvarlink(globals, "TradeQtyType_SHORT_SIDE_REJECTED_QUANTITY", Swig_var_TradeQtyType_SHORT_SIDE_REJECTED_QUANTITY_get, Swig_var_TradeQtyType_SHORT_SIDE_REJECTED_QUANTITY_set);
  SWIG_addvarlink(globals, "TradeQtyType_PENDING_QUANTITY", Swig_var_TradeQtyType_PENDING_QUANTITY_get, Swig_var_TradeQtyType_PENDING_QUANTITY_set);
  SWIG_addvarlink(globals, "TradeQtyType_TRANSACTION_QUANTITY", Swig_var_TradeQtyType_TRANSACTION_QUANTITY_get, Swig_var_TradeQtyType_TRANSACTION_QUANTITY_set);
  SWIG_addvarlink(globals, "TradeQtyType_REMAINING_QUANTITY", Swig_var_TradeQtyType_REMAINING_QUANTITY_get, Swig_var_TradeQtyType_REMAINING_QUANTITY_set);
  SWIG_addvarlink(globals, "TradeQtyType_PREVIOUS_REMAINING_QUANTITY", Swig_var_TradeQtyType_PREVIOUS_REMAINING_QUANTITY_get, Swig_var_TradeQtyType_PREVIOUS_REMAINING_QUANTITY_set);
  SWIG_addvarlink(globals, "TradeAllocGroupInstruction_ADD", Swig_var_TradeAllocGroupInstruction_ADD_get, Swig_var_TradeAllocGroupInstruction_ADD_set);
  SWIG_addvarlink(globals, "TradeAllocGroupInstruction_DO_NOT_ADD", Swig_var_TradeAllocGroupInstruction_DO_NOT_ADD_get, Swig_var_TradeAllocGroupInstruction_DO_NOT_ADD_set);
  SWIG_addvarlink(globals, "OffsetInstruction_OFFSET", Swig_var_OffsetInstruction_OFFSET_get, Swig_var_OffsetInstruction_OFFSET_set);
  SWIG_addvarlink(globals, "OffsetInstruction_ONSET", Swig_var_OffsetInstruction_ONSET_get, Swig_var_OffsetInstruction_ONSET_set);
  SWIG_addvarlink(globals, "SideAvgPxIndicator_NO_AVG_PRICING", Swig_var_SideAvgPxIndicator_NO_AVG_PRICING_get, Swig_var_SideAvgPxIndicator_NO_AVG_PRICING_set);
  SWIG_addvarlink(globals, "SideAvgPxIndicator_TRADE_IS_PART_AVG_PRICE_GRP", Swig_var_SideAvgPxIndicator_TRADE_IS_PART_AVG_PRICE_GRP_get, Swig_var_SideAvgPxIndicator_TRADE_IS_PART_AVG_PRICE_GRP_set);
  SWIG_addvarlink(globals, "SideAvgPxIndicator_LAST_TRADE_IS_PART_AVG_PRICE_GRP", Swig_var_SideAvgPxIndicator_LAST_TRADE_IS_PART_AVG_PRICE_GRP_get, Swig_var_SideAvgPxIndicator_LAST_TRADE_IS_PART_AVG_PRICE_GRP_set);
  SWIG_addvarlink(globals, "RelatedTradeIDSource_NON_FIX_SOURCE", Swig_var_RelatedTradeIDSource_NON_FIX_SOURCE_get, Swig_var_RelatedTradeIDSource_NON_FIX_SOURCE_set);
  SWIG_addvarlink(globals, "RelatedTradeIDSource_TRADE_ID", Swig_var_RelatedTradeIDSource_TRADE_ID_get, Swig_var_RelatedTradeIDSource_TRADE_ID_set);
  SWIG_addvarlink(globals, "RelatedTradeIDSource_SECONDARY_TRADE_ID", Swig_var_RelatedTradeIDSource_SECONDARY_TRADE_ID_get, Swig_var_RelatedTradeIDSource_SECONDARY_TRADE_ID_set);
  SWIG_addvarlink(globals, "RelatedTradeIDSource_TRADE_REPORT_ID", Swig_var_RelatedTradeIDSource_TRADE_REPORT_ID_get, Swig_var_RelatedTradeIDSource_TRADE_REPORT_ID_set);
  SWIG_addvarlink(globals, "RelatedTradeIDSource_FIRM_TRADE_ID", Swig_var_RelatedTradeIDSource_FIRM_TRADE_ID_get, Swig_var_RelatedTradeIDSource_FIRM_TRADE_ID_set);
  SWIG_addvarlink(globals, "RelatedTradeIDSource_SECONDARY_FIRM_TRADE_ID", Swig_var_RelatedTradeIDSource_SECONDARY_FIRM_TRADE_ID_get, Swig_var_RelatedTradeIDSource_SECONDARY_FIRM_TRADE_ID_set);
  SWIG_addvarlink(globals, "RelatedTradeIDSource_REGULATORY_TRADE_ID", Swig_var_RelatedTradeIDSource_REGULATORY_TRADE_ID_get, Swig_var_RelatedTradeIDSource_REGULATORY_TRADE_ID_set);
  SWIG_addvarlink(globals, "RelatedPositionIDSource_POS_MAINT_RPT_ID", Swig_var_RelatedPositionIDSource_POS_MAINT_RPT_ID_get, Swig_var_RelatedPositionIDSource_POS_MAINT_RPT_ID_set);
  SWIG_addvarlink(globals, "RelatedPositionIDSource_TRANSFER_ID", Swig_var_RelatedPositionIDSource_TRANSFER_ID_get, Swig_var_RelatedPositionIDSource_TRANSFER_ID_set);
  SWIG_addvarlink(globals, "RelatedPositionIDSource_POSITION_ENTITY_ID", Swig_var_RelatedPositionIDSource_POSITION_ENTITY_ID_get, Swig_var_RelatedPositionIDSource_POSITION_ENTITY_ID_set);
  SWIG_addvarlink(globals, "ValueCheckType_PRICE_CHECK", Swig_var_ValueCheckType_PRICE_CHECK_get, Swig_var_ValueCheckType_PRICE_CHECK_set);
  SWIG_addvarlink(globals, "ValueCheckType_NOTIONAL_VALUE_CHECK", Swig_var_ValueCheckType_NOTIONAL_VALUE_CHECK_get, Swig_var_ValueCheckType_NOTIONAL_VALUE_CHECK_set);
  SWIG_addvarlink(globals, "ValueCheckType_QUANTITY_CHECK", Swig_var_ValueCheckType_QUANTITY_CHECK_get, Swig_var_ValueCheckType_QUANTITY_CHECK_set);
  SWIG_addvarlink(globals, "ValueCheckAction_DO_NOT_CHECK", Swig_var_ValueCheckAction_DO_NOT_CHECK_get, Swig_var_ValueCheckAction_DO_NOT_CHECK_set);
  SWIG_addvarlink(globals, "ValueCheckAction_CHECK", Swig_var_ValueCheckAction_CHECK_get, Swig_var_ValueCheckAction_CHECK_set);
  SWIG_addvarlink(globals, "ValueCheckAction_BEST_EFFORT", Swig_var_ValueCheckAction_BEST_EFFORT_get, Swig_var_ValueCheckAction_BEST_EFFORT_set);
  SWIG_addvarlink(globals, "PartyDetailRequestResult_SUCCESSFUL", Swig_var_PartyDetailRequestResult_SUCCESSFUL_get, Swig_var_PartyDetailRequestResult_SUCCESSFUL_set);
  SWIG_addvarlink(globals, "PartyDetailRequestResult_INVALID_PARTY", Swig_var_PartyDetailRequestResult_INVALID_PARTY_get, Swig_var_PartyDetailRequestResult_INVALID_PARTY_set);
  SWIG_addvarlink(globals, "PartyDetailRequestResult_INVALID_RELATED_PARTY", Swig_var_PartyDetailRequestResult_INVALID_RELATED_PARTY_get, Swig_var_PartyDetailRequestResult_INVALID_RELATED_PARTY_set);
  SWIG_addvarlink(globals, "PartyDetailRequestResult_INVALID_PARTY_STATUS", Swig_var_PartyDetailRequestResult_INVALID_PARTY_STATUS_get, Swig_var_PartyDetailRequestResult_INVALID_PARTY_STATUS_set);
  SWIG_addvarlink(globals, "PartyDetailRequestResult_NOT_AUTHORIZED", Swig_var_PartyDetailRequestResult_NOT_AUTHORIZED_get, Swig_var_PartyDetailRequestResult_NOT_AUTHORIZED_set);
  SWIG_addvarlink(globals, "PartyDetailRequestResult_OTHER", Swig_var_PartyDetailRequestResult_OTHER_get, Swig_var_PartyDetailRequestResult_OTHER_set);
  SWIG_addvarlink(globals, "PartyDetailRequestStatus_ACCEPTED", Swig_var_PartyDetailRequestStatus_ACCEPTED_get, Swig_var_PartyDetailRequestStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "PartyDetailRequestStatus_ACCEPTED_WITH_CHANGES", Swig_var_PartyDetailRequestStatus_ACCEPTED_WITH_CHANGES_get, Swig_var_PartyDetailRequestStatus_ACCEPTED_WITH_CHANGES_set);
  SWIG_addvarlink(globals, "PartyDetailRequestStatus_REJECTED", Swig_var_PartyDetailRequestStatus_REJECTED_get, Swig_var_PartyDetailRequestStatus_REJECTED_set);
  SWIG_addvarlink(globals, "PartyDetailRequestStatus_ACCEPTANCE_PENDING", Swig_var_PartyDetailRequestStatus_ACCEPTANCE_PENDING_get, Swig_var_PartyDetailRequestStatus_ACCEPTANCE_PENDING_set);
  SWIG_addvarlink(globals, "PartyDetailDefinitionStatus_ACCEPTED", Swig_var_PartyDetailDefinitionStatus_ACCEPTED_get, Swig_var_PartyDetailDefinitionStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "PartyDetailDefinitionStatus_ACCEPTED_WITH_CHANGES", Swig_var_PartyDetailDefinitionStatus_ACCEPTED_WITH_CHANGES_get, Swig_var_PartyDetailDefinitionStatus_ACCEPTED_WITH_CHANGES_set);
  SWIG_addvarlink(globals, "PartyDetailDefinitionStatus_REJECTED", Swig_var_PartyDetailDefinitionStatus_REJECTED_get, Swig_var_PartyDetailDefinitionStatus_REJECTED_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_SUCCESSFUL", Swig_var_EntitlementRequestResult_SUCCESSFUL_get, Swig_var_EntitlementRequestResult_SUCCESSFUL_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_INVALID_PARTY", Swig_var_EntitlementRequestResult_INVALID_PARTY_get, Swig_var_EntitlementRequestResult_INVALID_PARTY_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_INVALID_RELATED_PARTY", Swig_var_EntitlementRequestResult_INVALID_RELATED_PARTY_get, Swig_var_EntitlementRequestResult_INVALID_RELATED_PARTY_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_INVALID_ENTITLEMENT_TYPE", Swig_var_EntitlementRequestResult_INVALID_ENTITLEMENT_TYPE_get, Swig_var_EntitlementRequestResult_INVALID_ENTITLEMENT_TYPE_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_INVALID_ENTITLEMENT_ID", Swig_var_EntitlementRequestResult_INVALID_ENTITLEMENT_ID_get, Swig_var_EntitlementRequestResult_INVALID_ENTITLEMENT_ID_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_INVALID_ENTITLEMENT_ATTRIBUTE", Swig_var_EntitlementRequestResult_INVALID_ENTITLEMENT_ATTRIBUTE_get, Swig_var_EntitlementRequestResult_INVALID_ENTITLEMENT_ATTRIBUTE_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_INVALID_INSTRUMENT_SCOPE", Swig_var_EntitlementRequestResult_INVALID_INSTRUMENT_SCOPE_get, Swig_var_EntitlementRequestResult_INVALID_INSTRUMENT_SCOPE_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_INVALID_MARKET_SEGMENT_SCOPE", Swig_var_EntitlementRequestResult_INVALID_MARKET_SEGMENT_SCOPE_get, Swig_var_EntitlementRequestResult_INVALID_MARKET_SEGMENT_SCOPE_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_INVALID_START_DATE", Swig_var_EntitlementRequestResult_INVALID_START_DATE_get, Swig_var_EntitlementRequestResult_INVALID_START_DATE_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_INVALID_END_DATE", Swig_var_EntitlementRequestResult_INVALID_END_DATE_get, Swig_var_EntitlementRequestResult_INVALID_END_DATE_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_INSTRUMENT_SCOPE_NOT_SUPPORTED", Swig_var_EntitlementRequestResult_INSTRUMENT_SCOPE_NOT_SUPPORTED_get, Swig_var_EntitlementRequestResult_INSTRUMENT_SCOPE_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_MARKET_SEGMENT_SCOPE_NOT_SUPPORTED", Swig_var_EntitlementRequestResult_MARKET_SEGMENT_SCOPE_NOT_SUPPORTED_get, Swig_var_EntitlementRequestResult_MARKET_SEGMENT_SCOPE_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_ENTITLEMENT_NOT_APPROVED_FOR_PARTY", Swig_var_EntitlementRequestResult_ENTITLEMENT_NOT_APPROVED_FOR_PARTY_get, Swig_var_EntitlementRequestResult_ENTITLEMENT_NOT_APPROVED_FOR_PARTY_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_ENTITLEMENT_ALREADY_DEFINED_FOR_PARTY", Swig_var_EntitlementRequestResult_ENTITLEMENT_ALREADY_DEFINED_FOR_PARTY_get, Swig_var_EntitlementRequestResult_ENTITLEMENT_ALREADY_DEFINED_FOR_PARTY_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_INSTRUMENT_NOT_APPROVED_FOR_PARTY", Swig_var_EntitlementRequestResult_INSTRUMENT_NOT_APPROVED_FOR_PARTY_get, Swig_var_EntitlementRequestResult_INSTRUMENT_NOT_APPROVED_FOR_PARTY_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_NOT_AUTHORIZED", Swig_var_EntitlementRequestResult_NOT_AUTHORIZED_get, Swig_var_EntitlementRequestResult_NOT_AUTHORIZED_set);
  SWIG_addvarlink(globals, "EntitlementRequestResult_OTHER", Swig_var_EntitlementRequestResult_OTHER_get, Swig_var_EntitlementRequestResult_OTHER_set);
  SWIG_addvarlink(globals, "EntitlementStatus_ACCEPTED", Swig_var_EntitlementStatus_ACCEPTED_get, Swig_var_EntitlementStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "EntitlementStatus_ACCEPTED_WITH_CHANGES", Swig_var_EntitlementStatus_ACCEPTED_WITH_CHANGES_get, Swig_var_EntitlementStatus_ACCEPTED_WITH_CHANGES_set);
  SWIG_addvarlink(globals, "EntitlementStatus_REJECTED", Swig_var_EntitlementStatus_REJECTED_get, Swig_var_EntitlementStatus_REJECTED_set);
  SWIG_addvarlink(globals, "EntitlementStatus_PENDING", Swig_var_EntitlementStatus_PENDING_get, Swig_var_EntitlementStatus_PENDING_set);
  SWIG_addvarlink(globals, "EntitlementStatus_REQUESTED", Swig_var_EntitlementStatus_REQUESTED_get, Swig_var_EntitlementStatus_REQUESTED_set);
  SWIG_addvarlink(globals, "EntitlementStatus_DEFERRED", Swig_var_EntitlementStatus_DEFERRED_get, Swig_var_EntitlementStatus_DEFERRED_set);
  SWIG_addvarlink(globals, "TradeMatchAckStatus_RECEIVED_NOT_PROCESSED", Swig_var_TradeMatchAckStatus_RECEIVED_NOT_PROCESSED_get, Swig_var_TradeMatchAckStatus_RECEIVED_NOT_PROCESSED_set);
  SWIG_addvarlink(globals, "TradeMatchAckStatus_ACCEPTED", Swig_var_TradeMatchAckStatus_ACCEPTED_get, Swig_var_TradeMatchAckStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "TradeMatchAckStatus_REJECTED", Swig_var_TradeMatchAckStatus_REJECTED_get, Swig_var_TradeMatchAckStatus_REJECTED_set);
  SWIG_addvarlink(globals, "TradeMatchRejectReason_SUCCESSFUL", Swig_var_TradeMatchRejectReason_SUCCESSFUL_get, Swig_var_TradeMatchRejectReason_SUCCESSFUL_set);
  SWIG_addvarlink(globals, "TradeMatchRejectReason_INVALID_PARTY_INFORMATION", Swig_var_TradeMatchRejectReason_INVALID_PARTY_INFORMATION_get, Swig_var_TradeMatchRejectReason_INVALID_PARTY_INFORMATION_set);
  SWIG_addvarlink(globals, "TradeMatchRejectReason_UNKNOWN_INSTRUMENT", Swig_var_TradeMatchRejectReason_UNKNOWN_INSTRUMENT_get, Swig_var_TradeMatchRejectReason_UNKNOWN_INSTRUMENT_set);
  SWIG_addvarlink(globals, "TradeMatchRejectReason_UNAUTHORIZED", Swig_var_TradeMatchRejectReason_UNAUTHORIZED_get, Swig_var_TradeMatchRejectReason_UNAUTHORIZED_set);
  SWIG_addvarlink(globals, "TradeMatchRejectReason_INVALID_TRADE_TYPE", Swig_var_TradeMatchRejectReason_INVALID_TRADE_TYPE_get, Swig_var_TradeMatchRejectReason_INVALID_TRADE_TYPE_set);
  SWIG_addvarlink(globals, "TradeMatchRejectReason_OTHER", Swig_var_TradeMatchRejectReason_OTHER_get, Swig_var_TradeMatchRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "PriceMovementType_AMOUNT", Swig_var_PriceMovementType_AMOUNT_get, Swig_var_PriceMovementType_AMOUNT_set);
  SWIG_addvarlink(globals, "PriceMovementType_PERCENTAGE", Swig_var_PriceMovementType_PERCENTAGE_get, Swig_var_PriceMovementType_PERCENTAGE_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDEvent_INITIAL_BLOCK_TRADE", Swig_var_RegulatoryTradeIDEvent_INITIAL_BLOCK_TRADE_get, Swig_var_RegulatoryTradeIDEvent_INITIAL_BLOCK_TRADE_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDEvent_ALLOCATION", Swig_var_RegulatoryTradeIDEvent_ALLOCATION_get, Swig_var_RegulatoryTradeIDEvent_ALLOCATION_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDEvent_CLEARING", Swig_var_RegulatoryTradeIDEvent_CLEARING_get, Swig_var_RegulatoryTradeIDEvent_CLEARING_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDEvent_COMPRESSION", Swig_var_RegulatoryTradeIDEvent_COMPRESSION_get, Swig_var_RegulatoryTradeIDEvent_COMPRESSION_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDEvent_NOVATION", Swig_var_RegulatoryTradeIDEvent_NOVATION_get, Swig_var_RegulatoryTradeIDEvent_NOVATION_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDEvent_TERMINATION", Swig_var_RegulatoryTradeIDEvent_TERMINATION_get, Swig_var_RegulatoryTradeIDEvent_TERMINATION_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDEvent_POST_TRD_VAL", Swig_var_RegulatoryTradeIDEvent_POST_TRD_VAL_get, Swig_var_RegulatoryTradeIDEvent_POST_TRD_VAL_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDSource_UNIQUE_TRANSACTION_IDENTIFIER", Swig_var_RegulatoryTradeIDSource_UNIQUE_TRANSACTION_IDENTIFIER_get, Swig_var_RegulatoryTradeIDSource_UNIQUE_TRANSACTION_IDENTIFIER_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDType_CURRENT", Swig_var_RegulatoryTradeIDType_CURRENT_get, Swig_var_RegulatoryTradeIDType_CURRENT_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDType_PREVIOUS", Swig_var_RegulatoryTradeIDType_PREVIOUS_get, Swig_var_RegulatoryTradeIDType_PREVIOUS_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDType_BLOCK", Swig_var_RegulatoryTradeIDType_BLOCK_get, Swig_var_RegulatoryTradeIDType_BLOCK_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDType_RELATED", Swig_var_RegulatoryTradeIDType_RELATED_get, Swig_var_RegulatoryTradeIDType_RELATED_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDType_CLEARED_BLOCK_TRADE", Swig_var_RegulatoryTradeIDType_CLEARED_BLOCK_TRADE_get, Swig_var_RegulatoryTradeIDType_CLEARED_BLOCK_TRADE_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDType_TRADING_VENUE_TRANSACTION_IDENTIFIER", Swig_var_RegulatoryTradeIDType_TRADING_VENUE_TRANSACTION_IDENTIFIER_get, Swig_var_RegulatoryTradeIDType_TRADING_VENUE_TRANSACTION_IDENTIFIER_set);
  SWIG_addvarlink(globals, "ClearingIntention_DO_NOT_INTEND_TO_CLEAR", Swig_var_ClearingIntention_DO_NOT_INTEND_TO_CLEAR_get, Swig_var_ClearingIntention_DO_NOT_INTEND_TO_CLEAR_set);
  SWIG_addvarlink(globals, "ClearingIntention_INTEND_TO_CLEAR", Swig_var_ClearingIntention_INTEND_TO_CLEAR_get, Swig_var_ClearingIntention_INTEND_TO_CLEAR_set);
  SWIG_addvarlink(globals, "ConfirmationMethod_NON_ELECTRONIC", Swig_var_ConfirmationMethod_NON_ELECTRONIC_get, Swig_var_ConfirmationMethod_NON_ELECTRONIC_set);
  SWIG_addvarlink(globals, "ConfirmationMethod_ELECTRONIC", Swig_var_ConfirmationMethod_ELECTRONIC_get, Swig_var_ConfirmationMethod_ELECTRONIC_set);
  SWIG_addvarlink(globals, "ConfirmationMethod_UNCONFIRMED", Swig_var_ConfirmationMethod_UNCONFIRMED_get, Swig_var_ConfirmationMethod_UNCONFIRMED_set);
  SWIG_addvarlink(globals, "VerificationMethod_NON_ELECTRONIC", Swig_var_VerificationMethod_NON_ELECTRONIC_get, Swig_var_VerificationMethod_NON_ELECTRONIC_set);
  SWIG_addvarlink(globals, "VerificationMethod_ELECTRONIC", Swig_var_VerificationMethod_ELECTRONIC_get, Swig_var_VerificationMethod_ELECTRONIC_set);
  SWIG_addvarlink(globals, "ClearingRequirementException_NO_EXCEPTION", Swig_var_ClearingRequirementException_NO_EXCEPTION_get, Swig_var_ClearingRequirementException_NO_EXCEPTION_set);
  SWIG_addvarlink(globals, "ClearingRequirementException_EXCEPTION", Swig_var_ClearingRequirementException_EXCEPTION_get, Swig_var_ClearingRequirementException_EXCEPTION_set);
  SWIG_addvarlink(globals, "ClearingRequirementException_END_USER_EXCEPTION", Swig_var_ClearingRequirementException_END_USER_EXCEPTION_get, Swig_var_ClearingRequirementException_END_USER_EXCEPTION_set);
  SWIG_addvarlink(globals, "ClearingRequirementException_INTER_AFFILIATE_EXCEPTION", Swig_var_ClearingRequirementException_INTER_AFFILIATE_EXCEPTION_get, Swig_var_ClearingRequirementException_INTER_AFFILIATE_EXCEPTION_set);
  SWIG_addvarlink(globals, "ClearingRequirementException_TREASURY_AFFILIATE_EXCEPTION", Swig_var_ClearingRequirementException_TREASURY_AFFILIATE_EXCEPTION_get, Swig_var_ClearingRequirementException_TREASURY_AFFILIATE_EXCEPTION_set);
  SWIG_addvarlink(globals, "ClearingRequirementException_COOPERATIVE_EXCEPTION", Swig_var_ClearingRequirementException_COOPERATIVE_EXCEPTION_get, Swig_var_ClearingRequirementException_COOPERATIVE_EXCEPTION_set);
  SWIG_addvarlink(globals, "IRSDirection_PAY", Swig_var_IRSDirection_PAY_get, Swig_var_IRSDirection_PAY_set);
  SWIG_addvarlink(globals, "IRSDirection_RCV", Swig_var_IRSDirection_RCV_get, Swig_var_IRSDirection_RCV_set);
  SWIG_addvarlink(globals, "IRSDirection_NA", Swig_var_IRSDirection_NA_get, Swig_var_IRSDirection_NA_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_RT", Swig_var_RegulatoryReportType_RT_get, Swig_var_RegulatoryReportType_RT_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_PET", Swig_var_RegulatoryReportType_PET_get, Swig_var_RegulatoryReportType_PET_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_SNAPSHOT", Swig_var_RegulatoryReportType_SNAPSHOT_get, Swig_var_RegulatoryReportType_SNAPSHOT_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_CONFIRMATION", Swig_var_RegulatoryReportType_CONFIRMATION_get, Swig_var_RegulatoryReportType_CONFIRMATION_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_RTPET", Swig_var_RegulatoryReportType_RTPET_get, Swig_var_RegulatoryReportType_RTPET_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_PET_CONFIRMATION", Swig_var_RegulatoryReportType_PET_CONFIRMATION_get, Swig_var_RegulatoryReportType_PET_CONFIRMATION_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_RTPET_CONFIRMATION", Swig_var_RegulatoryReportType_RTPET_CONFIRMATION_get, Swig_var_RegulatoryReportType_RTPET_CONFIRMATION_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_POST_TRADE", Swig_var_RegulatoryReportType_POST_TRADE_get, Swig_var_RegulatoryReportType_POST_TRADE_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_VERIFICATION", Swig_var_RegulatoryReportType_VERIFICATION_get, Swig_var_RegulatoryReportType_VERIFICATION_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_PST_TRD_EVNT", Swig_var_RegulatoryReportType_PST_TRD_EVNT_get, Swig_var_RegulatoryReportType_PST_TRD_EVNT_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_PST_TRD_EVNT_RT_REPORTABLE", Swig_var_RegulatoryReportType_PST_TRD_EVNT_RT_REPORTABLE_get, Swig_var_RegulatoryReportType_PST_TRD_EVNT_RT_REPORTABLE_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_LMTF", Swig_var_RegulatoryReportType_LMTF_get, Swig_var_RegulatoryReportType_LMTF_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_DATF", Swig_var_RegulatoryReportType_DATF_get, Swig_var_RegulatoryReportType_DATF_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_VOLO", Swig_var_RegulatoryReportType_VOLO_get, Swig_var_RegulatoryReportType_VOLO_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_FWAF", Swig_var_RegulatoryReportType_FWAF_get, Swig_var_RegulatoryReportType_FWAF_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_IDAF", Swig_var_RegulatoryReportType_IDAF_get, Swig_var_RegulatoryReportType_IDAF_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_VOLW", Swig_var_RegulatoryReportType_VOLW_get, Swig_var_RegulatoryReportType_VOLW_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_FULF", Swig_var_RegulatoryReportType_FULF_get, Swig_var_RegulatoryReportType_FULF_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_FULA", Swig_var_RegulatoryReportType_FULA_get, Swig_var_RegulatoryReportType_FULA_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_FULV", Swig_var_RegulatoryReportType_FULV_get, Swig_var_RegulatoryReportType_FULV_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_FULJ", Swig_var_RegulatoryReportType_FULJ_get, Swig_var_RegulatoryReportType_FULJ_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_COAF", Swig_var_RegulatoryReportType_COAF_get, Swig_var_RegulatoryReportType_COAF_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_ORDER", Swig_var_RegulatoryReportType_ORDER_get, Swig_var_RegulatoryReportType_ORDER_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_CHILD_ORDER", Swig_var_RegulatoryReportType_CHILD_ORDER_get, Swig_var_RegulatoryReportType_CHILD_ORDER_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_ORDER_ROUTE", Swig_var_RegulatoryReportType_ORDER_ROUTE_get, Swig_var_RegulatoryReportType_ORDER_ROUTE_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_TRADE", Swig_var_RegulatoryReportType_TRADE_get, Swig_var_RegulatoryReportType_TRADE_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_QUOTE", Swig_var_RegulatoryReportType_QUOTE_get, Swig_var_RegulatoryReportType_QUOTE_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_SUPPLEMENT", Swig_var_RegulatoryReportType_SUPPLEMENT_get, Swig_var_RegulatoryReportType_SUPPLEMENT_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_NEW_TRANSACTION", Swig_var_RegulatoryReportType_NEW_TRANSACTION_get, Swig_var_RegulatoryReportType_NEW_TRANSACTION_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_TRANSACTION_CORRECTION", Swig_var_RegulatoryReportType_TRANSACTION_CORRECTION_get, Swig_var_RegulatoryReportType_TRANSACTION_CORRECTION_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_TRANSACTION_MODIFICATION", Swig_var_RegulatoryReportType_TRANSACTION_MODIFICATION_get, Swig_var_RegulatoryReportType_TRANSACTION_MODIFICATION_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_COLLATERAL_UPDATE", Swig_var_RegulatoryReportType_COLLATERAL_UPDATE_get, Swig_var_RegulatoryReportType_COLLATERAL_UPDATE_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_MARGIN_UPDATE", Swig_var_RegulatoryReportType_MARGIN_UPDATE_get, Swig_var_RegulatoryReportType_MARGIN_UPDATE_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_TRANSACTION_REPORTED_IN_ERROR", Swig_var_RegulatoryReportType_TRANSACTION_REPORTED_IN_ERROR_get, Swig_var_RegulatoryReportType_TRANSACTION_REPORTED_IN_ERROR_set);
  SWIG_addvarlink(globals, "RegulatoryReportType_TERMINATION_EARLY_TERMINATION", Swig_var_RegulatoryReportType_TERMINATION_EARLY_TERMINATION_get, Swig_var_RegulatoryReportType_TERMINATION_EARLY_TERMINATION_set);
  SWIG_addvarlink(globals, "TradeCollateralization_UNCOLLATERALIZED", Swig_var_TradeCollateralization_UNCOLLATERALIZED_get, Swig_var_TradeCollateralization_UNCOLLATERALIZED_set);
  SWIG_addvarlink(globals, "TradeCollateralization_PARTIALLY_COLLATERALIZED", Swig_var_TradeCollateralization_PARTIALLY_COLLATERALIZED_get, Swig_var_TradeCollateralization_PARTIALLY_COLLATERALIZED_set);
  SWIG_addvarlink(globals, "TradeCollateralization_ONE_WAY_COLLATERALLIZATION", Swig_var_TradeCollateralization_ONE_WAY_COLLATERALLIZATION_get, Swig_var_TradeCollateralization_ONE_WAY_COLLATERALLIZATION_set);
  SWIG_addvarlink(globals, "TradeCollateralization_FULLY_COLLATERALIZED", Swig_var_TradeCollateralization_FULLY_COLLATERALIZED_get, Swig_var_TradeCollateralization_FULLY_COLLATERALIZED_set);
  SWIG_addvarlink(globals, "TradeCollateralization_NET_EXPOSURE", Swig_var_TradeCollateralization_NET_EXPOSURE_get, Swig_var_TradeCollateralization_NET_EXPOSURE_set);
  SWIG_addvarlink(globals, "TradeContinuation_NOVATION", Swig_var_TradeContinuation_NOVATION_get, Swig_var_TradeContinuation_NOVATION_set);
  SWIG_addvarlink(globals, "TradeContinuation_PARTIAL_NOVATION", Swig_var_TradeContinuation_PARTIAL_NOVATION_get, Swig_var_TradeContinuation_PARTIAL_NOVATION_set);
  SWIG_addvarlink(globals, "TradeContinuation_TRADE_UNWIND", Swig_var_TradeContinuation_TRADE_UNWIND_get, Swig_var_TradeContinuation_TRADE_UNWIND_set);
  SWIG_addvarlink(globals, "TradeContinuation_PARTIAL_TRADE_UNWIND", Swig_var_TradeContinuation_PARTIAL_TRADE_UNWIND_get, Swig_var_TradeContinuation_PARTIAL_TRADE_UNWIND_set);
  SWIG_addvarlink(globals, "TradeContinuation_EXERCISE", Swig_var_TradeContinuation_EXERCISE_get, Swig_var_TradeContinuation_EXERCISE_set);
  SWIG_addvarlink(globals, "TradeContinuation_NETTING", Swig_var_TradeContinuation_NETTING_get, Swig_var_TradeContinuation_NETTING_set);
  SWIG_addvarlink(globals, "TradeContinuation_FULL_NETTING", Swig_var_TradeContinuation_FULL_NETTING_get, Swig_var_TradeContinuation_FULL_NETTING_set);
  SWIG_addvarlink(globals, "TradeContinuation_PARTIAL_NETTING", Swig_var_TradeContinuation_PARTIAL_NETTING_get, Swig_var_TradeContinuation_PARTIAL_NETTING_set);
  SWIG_addvarlink(globals, "TradeContinuation_AMENDMENT", Swig_var_TradeContinuation_AMENDMENT_get, Swig_var_TradeContinuation_AMENDMENT_set);
  SWIG_addvarlink(globals, "TradeContinuation_INCREASE", Swig_var_TradeContinuation_INCREASE_get, Swig_var_TradeContinuation_INCREASE_set);
  SWIG_addvarlink(globals, "TradeContinuation_CREDIT_EVENT", Swig_var_TradeContinuation_CREDIT_EVENT_get, Swig_var_TradeContinuation_CREDIT_EVENT_set);
  SWIG_addvarlink(globals, "TradeContinuation_STRATEGIC_RESTRUCTURING", Swig_var_TradeContinuation_STRATEGIC_RESTRUCTURING_get, Swig_var_TradeContinuation_STRATEGIC_RESTRUCTURING_set);
  SWIG_addvarlink(globals, "TradeContinuation_SUCCESSION_EVENT_REORGANIZATION", Swig_var_TradeContinuation_SUCCESSION_EVENT_REORGANIZATION_get, Swig_var_TradeContinuation_SUCCESSION_EVENT_REORGANIZATION_set);
  SWIG_addvarlink(globals, "TradeContinuation_SUCCESSION_EVENT_RENAMING", Swig_var_TradeContinuation_SUCCESSION_EVENT_RENAMING_get, Swig_var_TradeContinuation_SUCCESSION_EVENT_RENAMING_set);
  SWIG_addvarlink(globals, "TradeContinuation_PORTING", Swig_var_TradeContinuation_PORTING_get, Swig_var_TradeContinuation_PORTING_set);
  SWIG_addvarlink(globals, "TradeContinuation_WITHDRAWL", Swig_var_TradeContinuation_WITHDRAWL_get, Swig_var_TradeContinuation_WITHDRAWL_set);
  SWIG_addvarlink(globals, "TradeContinuation_VOID", Swig_var_TradeContinuation_VOID_get, Swig_var_TradeContinuation_VOID_set);
  SWIG_addvarlink(globals, "TradeContinuation_ACCOUNT_TRANSFER", Swig_var_TradeContinuation_ACCOUNT_TRANSFER_get, Swig_var_TradeContinuation_ACCOUNT_TRANSFER_set);
  SWIG_addvarlink(globals, "TradeContinuation_GIVE_UP", Swig_var_TradeContinuation_GIVE_UP_get, Swig_var_TradeContinuation_GIVE_UP_set);
  SWIG_addvarlink(globals, "TradeContinuation_TAKE_UP", Swig_var_TradeContinuation_TAKE_UP_get, Swig_var_TradeContinuation_TAKE_UP_set);
  SWIG_addvarlink(globals, "TradeContinuation_AVERAGE_PRICING", Swig_var_TradeContinuation_AVERAGE_PRICING_get, Swig_var_TradeContinuation_AVERAGE_PRICING_set);
  SWIG_addvarlink(globals, "TradeContinuation_REVERSAL", Swig_var_TradeContinuation_REVERSAL_get, Swig_var_TradeContinuation_REVERSAL_set);
  SWIG_addvarlink(globals, "TradeContinuation_ALLOC_TRD_POSTING", Swig_var_TradeContinuation_ALLOC_TRD_POSTING_get, Swig_var_TradeContinuation_ALLOC_TRD_POSTING_set);
  SWIG_addvarlink(globals, "TradeContinuation_CASCADE", Swig_var_TradeContinuation_CASCADE_get, Swig_var_TradeContinuation_CASCADE_set);
  SWIG_addvarlink(globals, "TradeContinuation_DELIVERY", Swig_var_TradeContinuation_DELIVERY_get, Swig_var_TradeContinuation_DELIVERY_set);
  SWIG_addvarlink(globals, "TradeContinuation_OPTION_ASGN", Swig_var_TradeContinuation_OPTION_ASGN_get, Swig_var_TradeContinuation_OPTION_ASGN_set);
  SWIG_addvarlink(globals, "TradeContinuation_EXPIRATION", Swig_var_TradeContinuation_EXPIRATION_get, Swig_var_TradeContinuation_EXPIRATION_set);
  SWIG_addvarlink(globals, "TradeContinuation_MATURITY", Swig_var_TradeContinuation_MATURITY_get, Swig_var_TradeContinuation_MATURITY_set);
  SWIG_addvarlink(globals, "TradeContinuation_EQUAL_POS_ADJ", Swig_var_TradeContinuation_EQUAL_POS_ADJ_get, Swig_var_TradeContinuation_EQUAL_POS_ADJ_set);
  SWIG_addvarlink(globals, "TradeContinuation_UNEQUAL_POS_ADJ", Swig_var_TradeContinuation_UNEQUAL_POS_ADJ_get, Swig_var_TradeContinuation_UNEQUAL_POS_ADJ_set);
  SWIG_addvarlink(globals, "TradeContinuation_CORRECTION", Swig_var_TradeContinuation_CORRECTION_get, Swig_var_TradeContinuation_CORRECTION_set);
  SWIG_addvarlink(globals, "TradeContinuation_EARLY_TERMINATION", Swig_var_TradeContinuation_EARLY_TERMINATION_get, Swig_var_TradeContinuation_EARLY_TERMINATION_set);
  SWIG_addvarlink(globals, "TradeContinuation_RERATE", Swig_var_TradeContinuation_RERATE_get, Swig_var_TradeContinuation_RERATE_set);
  SWIG_addvarlink(globals, "TradeContinuation_OTHER", Swig_var_TradeContinuation_OTHER_get, Swig_var_TradeContinuation_OTHER_set);
  SWIG_addvarlink(globals, "AssetClass_INTEREST_RATE", Swig_var_AssetClass_INTEREST_RATE_get, Swig_var_AssetClass_INTEREST_RATE_set);
  SWIG_addvarlink(globals, "AssetClass_CURRENCY", Swig_var_AssetClass_CURRENCY_get, Swig_var_AssetClass_CURRENCY_set);
  SWIG_addvarlink(globals, "AssetClass_CREDIT", Swig_var_AssetClass_CREDIT_get, Swig_var_AssetClass_CREDIT_set);
  SWIG_addvarlink(globals, "AssetClass_EQUITY", Swig_var_AssetClass_EQUITY_get, Swig_var_AssetClass_EQUITY_set);
  SWIG_addvarlink(globals, "AssetClass_COMMODITY", Swig_var_AssetClass_COMMODITY_get, Swig_var_AssetClass_COMMODITY_set);
  SWIG_addvarlink(globals, "AssetClass_OTHER", Swig_var_AssetClass_OTHER_get, Swig_var_AssetClass_OTHER_set);
  SWIG_addvarlink(globals, "AssetClass_CASH", Swig_var_AssetClass_CASH_get, Swig_var_AssetClass_CASH_set);
  SWIG_addvarlink(globals, "AssetClass_DEBT", Swig_var_AssetClass_DEBT_get, Swig_var_AssetClass_DEBT_set);
  SWIG_addvarlink(globals, "AssetClass_FUND", Swig_var_AssetClass_FUND_get, Swig_var_AssetClass_FUND_set);
  SWIG_addvarlink(globals, "AssetClass_LOAN_FACILITY", Swig_var_AssetClass_LOAN_FACILITY_get, Swig_var_AssetClass_LOAN_FACILITY_set);
  SWIG_addvarlink(globals, "AssetClass_INDEX", Swig_var_AssetClass_INDEX_get, Swig_var_AssetClass_INDEX_set);
  SWIG_addvarlink(globals, "AssetSubClass_METALS", Swig_var_AssetSubClass_METALS_get, Swig_var_AssetSubClass_METALS_set);
  SWIG_addvarlink(globals, "AssetSubClass_BULLION", Swig_var_AssetSubClass_BULLION_get, Swig_var_AssetSubClass_BULLION_set);
  SWIG_addvarlink(globals, "AssetSubClass_ENERGY", Swig_var_AssetSubClass_ENERGY_get, Swig_var_AssetSubClass_ENERGY_set);
  SWIG_addvarlink(globals, "AssetSubClass_COMMODITY_INDEX", Swig_var_AssetSubClass_COMMODITY_INDEX_get, Swig_var_AssetSubClass_COMMODITY_INDEX_set);
  SWIG_addvarlink(globals, "AssetSubClass_AGRICULTURAL", Swig_var_AssetSubClass_AGRICULTURAL_get, Swig_var_AssetSubClass_AGRICULTURAL_set);
  SWIG_addvarlink(globals, "AssetSubClass_ENVIRONMENTAL", Swig_var_AssetSubClass_ENVIRONMENTAL_get, Swig_var_AssetSubClass_ENVIRONMENTAL_set);
  SWIG_addvarlink(globals, "AssetSubClass_FREIGHT", Swig_var_AssetSubClass_FREIGHT_get, Swig_var_AssetSubClass_FREIGHT_set);
  SWIG_addvarlink(globals, "AssetSubClass_FERTILIZER", Swig_var_AssetSubClass_FERTILIZER_get, Swig_var_AssetSubClass_FERTILIZER_set);
  SWIG_addvarlink(globals, "AssetSubClass_INDUSTRIAL_PRODUCT", Swig_var_AssetSubClass_INDUSTRIAL_PRODUCT_get, Swig_var_AssetSubClass_INDUSTRIAL_PRODUCT_set);
  SWIG_addvarlink(globals, "AssetSubClass_INFLATION", Swig_var_AssetSubClass_INFLATION_get, Swig_var_AssetSubClass_INFLATION_set);
  SWIG_addvarlink(globals, "AssetSubClass_PAPER", Swig_var_AssetSubClass_PAPER_get, Swig_var_AssetSubClass_PAPER_set);
  SWIG_addvarlink(globals, "AssetSubClass_POLYPROPYLENE", Swig_var_AssetSubClass_POLYPROPYLENE_get, Swig_var_AssetSubClass_POLYPROPYLENE_set);
  SWIG_addvarlink(globals, "AssetSubClass_OFFICIAL_ECONOMIC_STATISTICS", Swig_var_AssetSubClass_OFFICIAL_ECONOMIC_STATISTICS_get, Swig_var_AssetSubClass_OFFICIAL_ECONOMIC_STATISTICS_set);
  SWIG_addvarlink(globals, "AssetSubClass_SINGLE_NAME", Swig_var_AssetSubClass_SINGLE_NAME_get, Swig_var_AssetSubClass_SINGLE_NAME_set);
  SWIG_addvarlink(globals, "AssetSubClass_CREDIT_INDEX", Swig_var_AssetSubClass_CREDIT_INDEX_get, Swig_var_AssetSubClass_CREDIT_INDEX_set);
  SWIG_addvarlink(globals, "AssetSubClass_INDEX_TRANCHE", Swig_var_AssetSubClass_INDEX_TRANCHE_get, Swig_var_AssetSubClass_INDEX_TRANCHE_set);
  SWIG_addvarlink(globals, "AssetSubClass_CREDIT_BASKET", Swig_var_AssetSubClass_CREDIT_BASKET_get, Swig_var_AssetSubClass_CREDIT_BASKET_set);
  SWIG_addvarlink(globals, "AssetSubClass_BASKET", Swig_var_AssetSubClass_BASKET_get, Swig_var_AssetSubClass_BASKET_set);
  SWIG_addvarlink(globals, "AssetSubClass_FX_CROSS_RATES", Swig_var_AssetSubClass_FX_CROSS_RATES_get, Swig_var_AssetSubClass_FX_CROSS_RATES_set);
  SWIG_addvarlink(globals, "AssetSubClass_FX_EMERGING_MARKETS", Swig_var_AssetSubClass_FX_EMERGING_MARKETS_get, Swig_var_AssetSubClass_FX_EMERGING_MARKETS_set);
  SWIG_addvarlink(globals, "AssetSubClass_FX_MAJORS", Swig_var_AssetSubClass_FX_MAJORS_get, Swig_var_AssetSubClass_FX_MAJORS_set);
  SWIG_addvarlink(globals, "AssetSubClass_GOVERNMENT", Swig_var_AssetSubClass_GOVERNMENT_get, Swig_var_AssetSubClass_GOVERNMENT_set);
  SWIG_addvarlink(globals, "AssetSubClass_AGENCY", Swig_var_AssetSubClass_AGENCY_get, Swig_var_AssetSubClass_AGENCY_set);
  SWIG_addvarlink(globals, "AssetSubClass_CORPORATE", Swig_var_AssetSubClass_CORPORATE_get, Swig_var_AssetSubClass_CORPORATE_set);
  SWIG_addvarlink(globals, "AssetSubClass_FINANCING", Swig_var_AssetSubClass_FINANCING_get, Swig_var_AssetSubClass_FINANCING_set);
  SWIG_addvarlink(globals, "AssetSubClass_MONEY_MARKET", Swig_var_AssetSubClass_MONEY_MARKET_get, Swig_var_AssetSubClass_MONEY_MARKET_set);
  SWIG_addvarlink(globals, "AssetSubClass_MORTGAGE", Swig_var_AssetSubClass_MORTGAGE_get, Swig_var_AssetSubClass_MORTGAGE_set);
  SWIG_addvarlink(globals, "AssetSubClass_MUNICIPAL", Swig_var_AssetSubClass_MUNICIPAL_get, Swig_var_AssetSubClass_MUNICIPAL_set);
  SWIG_addvarlink(globals, "AssetSubClass_COMMON", Swig_var_AssetSubClass_COMMON_get, Swig_var_AssetSubClass_COMMON_set);
  SWIG_addvarlink(globals, "AssetSubClass_PREFERRED", Swig_var_AssetSubClass_PREFERRED_get, Swig_var_AssetSubClass_PREFERRED_set);
  SWIG_addvarlink(globals, "AssetSubClass_EQUITY_INDEX", Swig_var_AssetSubClass_EQUITY_INDEX_get, Swig_var_AssetSubClass_EQUITY_INDEX_set);
  SWIG_addvarlink(globals, "AssetSubClass_EQUITY_BASKET", Swig_var_AssetSubClass_EQUITY_BASKET_get, Swig_var_AssetSubClass_EQUITY_BASKET_set);
  SWIG_addvarlink(globals, "AssetSubClass_DIVIDEND_INDEX", Swig_var_AssetSubClass_DIVIDEND_INDEX_get, Swig_var_AssetSubClass_DIVIDEND_INDEX_set);
  SWIG_addvarlink(globals, "AssetSubClass_STOCK_DIVIDEND", Swig_var_AssetSubClass_STOCK_DIVIDEND_get, Swig_var_AssetSubClass_STOCK_DIVIDEND_set);
  SWIG_addvarlink(globals, "AssetSubClass_EXCHANGE_TRADED_FUND", Swig_var_AssetSubClass_EXCHANGE_TRADED_FUND_get, Swig_var_AssetSubClass_EXCHANGE_TRADED_FUND_set);
  SWIG_addvarlink(globals, "AssetSubClass_VOLATILITY_INDEX", Swig_var_AssetSubClass_VOLATILITY_INDEX_get, Swig_var_AssetSubClass_VOLATILITY_INDEX_set);
  SWIG_addvarlink(globals, "AssetSubClass_MUTUAL_FUND", Swig_var_AssetSubClass_MUTUAL_FUND_get, Swig_var_AssetSubClass_MUTUAL_FUND_set);
  SWIG_addvarlink(globals, "AssetSubClass_COLLECTIVE_INVESTMENT_VEHICLE", Swig_var_AssetSubClass_COLLECTIVE_INVESTMENT_VEHICLE_get, Swig_var_AssetSubClass_COLLECTIVE_INVESTMENT_VEHICLE_set);
  SWIG_addvarlink(globals, "AssetSubClass_INVESTMENT_PROGRAM", Swig_var_AssetSubClass_INVESTMENT_PROGRAM_get, Swig_var_AssetSubClass_INVESTMENT_PROGRAM_set);
  SWIG_addvarlink(globals, "AssetSubClass_SPECIALIZED_ACCOUNT_PROGRAM", Swig_var_AssetSubClass_SPECIALIZED_ACCOUNT_PROGRAM_get, Swig_var_AssetSubClass_SPECIALIZED_ACCOUNT_PROGRAM_set);
  SWIG_addvarlink(globals, "AssetSubClass_SINGLE_CURRENCY", Swig_var_AssetSubClass_SINGLE_CURRENCY_get, Swig_var_AssetSubClass_SINGLE_CURRENCY_set);
  SWIG_addvarlink(globals, "AssetSubClass_CROSS_CURRENCY", Swig_var_AssetSubClass_CROSS_CURRENCY_get, Swig_var_AssetSubClass_CROSS_CURRENCY_set);
  SWIG_addvarlink(globals, "AssetSubClass_TERM_LOAN", Swig_var_AssetSubClass_TERM_LOAN_get, Swig_var_AssetSubClass_TERM_LOAN_set);
  SWIG_addvarlink(globals, "AssetSubClass_BRIDGE_LOAN", Swig_var_AssetSubClass_BRIDGE_LOAN_get, Swig_var_AssetSubClass_BRIDGE_LOAN_set);
  SWIG_addvarlink(globals, "AssetSubClass_LETTER_OF_CREDIT", Swig_var_AssetSubClass_LETTER_OF_CREDIT_get, Swig_var_AssetSubClass_LETTER_OF_CREDIT_set);
  SWIG_addvarlink(globals, "AssetSubClass_EXOTIC", Swig_var_AssetSubClass_EXOTIC_get, Swig_var_AssetSubClass_EXOTIC_set);
  SWIG_addvarlink(globals, "AssetSubClass_OTHER_C10", Swig_var_AssetSubClass_OTHER_C10_get, Swig_var_AssetSubClass_OTHER_C10_set);
  SWIG_addvarlink(globals, "AssetSubClass_OTHER", Swig_var_AssetSubClass_OTHER_get, Swig_var_AssetSubClass_OTHER_set);
  SWIG_addvarlink(globals, "SwapClass_BASIS_SWAP", Swig_var_SwapClass_BASIS_SWAP_get, Swig_var_SwapClass_BASIS_SWAP_set);
  SWIG_addvarlink(globals, "SwapClass_INDEX_SWAP", Swig_var_SwapClass_INDEX_SWAP_get, Swig_var_SwapClass_INDEX_SWAP_set);
  SWIG_addvarlink(globals, "SwapClass_BROAD_BASED_SECURITY_SWAP", Swig_var_SwapClass_BROAD_BASED_SECURITY_SWAP_get, Swig_var_SwapClass_BROAD_BASED_SECURITY_SWAP_set);
  SWIG_addvarlink(globals, "SwapClass_BASKET_SWAP", Swig_var_SwapClass_BASKET_SWAP_get, Swig_var_SwapClass_BASKET_SWAP_set);
  SWIG_addvarlink(globals, "CouponType_ZERO", Swig_var_CouponType_ZERO_get, Swig_var_CouponType_ZERO_set);
  SWIG_addvarlink(globals, "CouponType_FIXED_RATE", Swig_var_CouponType_FIXED_RATE_get, Swig_var_CouponType_FIXED_RATE_set);
  SWIG_addvarlink(globals, "CouponType_FLOATING_RATE", Swig_var_CouponType_FLOATING_RATE_get, Swig_var_CouponType_FLOATING_RATE_set);
  SWIG_addvarlink(globals, "CouponType_STRUCTURED", Swig_var_CouponType_STRUCTURED_get, Swig_var_CouponType_STRUCTURED_set);
  SWIG_addvarlink(globals, "CouponFrequencyUnit_DAY", Swig_var_CouponFrequencyUnit_DAY_get, Swig_var_CouponFrequencyUnit_DAY_set);
  SWIG_addvarlink(globals, "CouponFrequencyUnit_WEEK", Swig_var_CouponFrequencyUnit_WEEK_get, Swig_var_CouponFrequencyUnit_WEEK_set);
  SWIG_addvarlink(globals, "CouponFrequencyUnit_MONTH", Swig_var_CouponFrequencyUnit_MONTH_get, Swig_var_CouponFrequencyUnit_MONTH_set);
  SWIG_addvarlink(globals, "CouponFrequencyUnit_YEAR", Swig_var_CouponFrequencyUnit_YEAR_get, Swig_var_CouponFrequencyUnit_YEAR_set);
  SWIG_addvarlink(globals, "CouponFrequencyUnit_HOUR", Swig_var_CouponFrequencyUnit_HOUR_get, Swig_var_CouponFrequencyUnit_HOUR_set);
  SWIG_addvarlink(globals, "CouponFrequencyUnit_MINUTE", Swig_var_CouponFrequencyUnit_MINUTE_get, Swig_var_CouponFrequencyUnit_MINUTE_set);
  SWIG_addvarlink(globals, "CouponFrequencyUnit_SECOND", Swig_var_CouponFrequencyUnit_SECOND_get, Swig_var_CouponFrequencyUnit_SECOND_set);
  SWIG_addvarlink(globals, "CouponFrequencyUnit_TERM", Swig_var_CouponFrequencyUnit_TERM_get, Swig_var_CouponFrequencyUnit_TERM_set);
  SWIG_addvarlink(globals, "CouponDayCount_ONE_ONE", Swig_var_CouponDayCount_ONE_ONE_get, Swig_var_CouponDayCount_ONE_ONE_set);
  SWIG_addvarlink(globals, "CouponDayCount_THIRTY_THREE_SIXTY_US", Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_US_get, Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_US_set);
  SWIG_addvarlink(globals, "CouponDayCount_THIRTY_THREE_SIXTY_SIA", Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_SIA_get, Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_SIA_set);
  SWIG_addvarlink(globals, "CouponDayCount_THIRTY_THREE_SIXTY_M", Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_M_get, Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_M_set);
  SWIG_addvarlink(globals, "CouponDayCount_THIRTY_E_THREE_SIXTY", Swig_var_CouponDayCount_THIRTY_E_THREE_SIXTY_get, Swig_var_CouponDayCount_THIRTY_E_THREE_SIXTY_set);
  SWIG_addvarlink(globals, "CouponDayCount_THIRTY_E_THREE_SIXTY_ISDA", Swig_var_CouponDayCount_THIRTY_E_THREE_SIXTY_ISDA_get, Swig_var_CouponDayCount_THIRTY_E_THREE_SIXTY_ISDA_set);
  SWIG_addvarlink(globals, "CouponDayCount_ACT_THREE_SIXTY", Swig_var_CouponDayCount_ACT_THREE_SIXTY_get, Swig_var_CouponDayCount_ACT_THREE_SIXTY_set);
  SWIG_addvarlink(globals, "CouponDayCount_ACT_THREE_SIXTY_FIVE_FIXED", Swig_var_CouponDayCount_ACT_THREE_SIXTY_FIVE_FIXED_get, Swig_var_CouponDayCount_ACT_THREE_SIXTY_FIVE_FIXED_set);
  SWIG_addvarlink(globals, "CouponDayCount_ACT_ACT_AFB", Swig_var_CouponDayCount_ACT_ACT_AFB_get, Swig_var_CouponDayCount_ACT_ACT_AFB_set);
  SWIG_addvarlink(globals, "CouponDayCount_ACT_ACT_ICMA", Swig_var_CouponDayCount_ACT_ACT_ICMA_get, Swig_var_CouponDayCount_ACT_ACT_ICMA_set);
  SWIG_addvarlink(globals, "CouponDayCount_ACT_ACT_ISMA_ULTIMO", Swig_var_CouponDayCount_ACT_ACT_ISMA_ULTIMO_get, Swig_var_CouponDayCount_ACT_ACT_ISMA_ULTIMO_set);
  SWIG_addvarlink(globals, "CouponDayCount_ACT_ACT_ISDA", Swig_var_CouponDayCount_ACT_ACT_ISDA_get, Swig_var_CouponDayCount_ACT_ACT_ISDA_set);
  SWIG_addvarlink(globals, "CouponDayCount_BUS_TWO_FIFTY_TWO", Swig_var_CouponDayCount_BUS_TWO_FIFTY_TWO_get, Swig_var_CouponDayCount_BUS_TWO_FIFTY_TWO_set);
  SWIG_addvarlink(globals, "CouponDayCount_THIRTY_E_PLUS_THREE_SIXTY", Swig_var_CouponDayCount_THIRTY_E_PLUS_THREE_SIXTY_get, Swig_var_CouponDayCount_THIRTY_E_PLUS_THREE_SIXTY_set);
  SWIG_addvarlink(globals, "CouponDayCount_ACT_THREE_SIXTY_FIVE_L", Swig_var_CouponDayCount_ACT_THREE_SIXTY_FIVE_L_get, Swig_var_CouponDayCount_ACT_THREE_SIXTY_FIVE_L_set);
  SWIG_addvarlink(globals, "CouponDayCount_NL_THREE_SIXTY_FIVE", Swig_var_CouponDayCount_NL_THREE_SIXTY_FIVE_get, Swig_var_CouponDayCount_NL_THREE_SIXTY_FIVE_set);
  SWIG_addvarlink(globals, "CouponDayCount_NL_THREE_SIXTY", Swig_var_CouponDayCount_NL_THREE_SIXTY_get, Swig_var_CouponDayCount_NL_THREE_SIXTY_set);
  SWIG_addvarlink(globals, "CouponDayCount_ACT364", Swig_var_CouponDayCount_ACT364_get, Swig_var_CouponDayCount_ACT364_set);
  SWIG_addvarlink(globals, "CouponDayCount_THIRTY_THREE_SIXTY_FIVE", Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_FIVE_get, Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_FIVE_set);
  SWIG_addvarlink(globals, "CouponDayCount_THIRTY_ACTUAL", Swig_var_CouponDayCount_THIRTY_ACTUAL_get, Swig_var_CouponDayCount_THIRTY_ACTUAL_set);
  SWIG_addvarlink(globals, "CouponDayCount_THIRTY_THREE_SIXTY_ICMA", Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_ICMA_get, Swig_var_CouponDayCount_THIRTY_THREE_SIXTY_ICMA_set);
  SWIG_addvarlink(globals, "CouponDayCount_THIRTY_E_TWO_THREE_SIXTY", Swig_var_CouponDayCount_THIRTY_E_TWO_THREE_SIXTY_get, Swig_var_CouponDayCount_THIRTY_E_TWO_THREE_SIXTY_set);
  SWIG_addvarlink(globals, "CouponDayCount_THIRTY_E_THREE_THREE_SIXTY", Swig_var_CouponDayCount_THIRTY_E_THREE_THREE_SIXTY_get, Swig_var_CouponDayCount_THIRTY_E_THREE_THREE_SIXTY_set);
  SWIG_addvarlink(globals, "CouponDayCount_OTHER", Swig_var_CouponDayCount_OTHER_get, Swig_var_CouponDayCount_OTHER_set);
  SWIG_addvarlink(globals, "LienSeniority_UNKNOWN", Swig_var_LienSeniority_UNKNOWN_get, Swig_var_LienSeniority_UNKNOWN_set);
  SWIG_addvarlink(globals, "LienSeniority_FIRST_LIEN", Swig_var_LienSeniority_FIRST_LIEN_get, Swig_var_LienSeniority_FIRST_LIEN_set);
  SWIG_addvarlink(globals, "LienSeniority_SECOND_LIEN", Swig_var_LienSeniority_SECOND_LIEN_get, Swig_var_LienSeniority_SECOND_LIEN_set);
  SWIG_addvarlink(globals, "LienSeniority_THIRD_LIEN", Swig_var_LienSeniority_THIRD_LIEN_get, Swig_var_LienSeniority_THIRD_LIEN_set);
  SWIG_addvarlink(globals, "LoanFacility_BRIDGE_LOAN", Swig_var_LoanFacility_BRIDGE_LOAN_get, Swig_var_LoanFacility_BRIDGE_LOAN_set);
  SWIG_addvarlink(globals, "LoanFacility_LETTER_OF_CREDIT", Swig_var_LoanFacility_LETTER_OF_CREDIT_get, Swig_var_LoanFacility_LETTER_OF_CREDIT_set);
  SWIG_addvarlink(globals, "LoanFacility_REVOLVING_LOAN", Swig_var_LoanFacility_REVOLVING_LOAN_get, Swig_var_LoanFacility_REVOLVING_LOAN_set);
  SWIG_addvarlink(globals, "LoanFacility_SWINGLINE_FUNDING", Swig_var_LoanFacility_SWINGLINE_FUNDING_get, Swig_var_LoanFacility_SWINGLINE_FUNDING_set);
  SWIG_addvarlink(globals, "LoanFacility_TERM_LOAN", Swig_var_LoanFacility_TERM_LOAN_get, Swig_var_LoanFacility_TERM_LOAN_set);
  SWIG_addvarlink(globals, "LoanFacility_TRADE_CLAIM", Swig_var_LoanFacility_TRADE_CLAIM_get, Swig_var_LoanFacility_TRADE_CLAIM_set);
  SWIG_addvarlink(globals, "ReferenceEntityType_ASIAN", Swig_var_ReferenceEntityType_ASIAN_get, Swig_var_ReferenceEntityType_ASIAN_set);
  SWIG_addvarlink(globals, "ReferenceEntityType_AUSTRALIAN_NEW_ZEALAND", Swig_var_ReferenceEntityType_AUSTRALIAN_NEW_ZEALAND_get, Swig_var_ReferenceEntityType_AUSTRALIAN_NEW_ZEALAND_set);
  SWIG_addvarlink(globals, "ReferenceEntityType_EUROPEAN_EMERGING_MARKETS", Swig_var_ReferenceEntityType_EUROPEAN_EMERGING_MARKETS_get, Swig_var_ReferenceEntityType_EUROPEAN_EMERGING_MARKETS_set);
  SWIG_addvarlink(globals, "ReferenceEntityType_JAPANESE", Swig_var_ReferenceEntityType_JAPANESE_get, Swig_var_ReferenceEntityType_JAPANESE_set);
  SWIG_addvarlink(globals, "ReferenceEntityType_NORTH_AMERICAN_HIGH_YIELD", Swig_var_ReferenceEntityType_NORTH_AMERICAN_HIGH_YIELD_get, Swig_var_ReferenceEntityType_NORTH_AMERICAN_HIGH_YIELD_set);
  SWIG_addvarlink(globals, "ReferenceEntityType_NORTH_AMERICAN_INSURANCE", Swig_var_ReferenceEntityType_NORTH_AMERICAN_INSURANCE_get, Swig_var_ReferenceEntityType_NORTH_AMERICAN_INSURANCE_set);
  SWIG_addvarlink(globals, "ReferenceEntityType_NORTH_AMERICAN_INVESTMENT_GRADE", Swig_var_ReferenceEntityType_NORTH_AMERICAN_INVESTMENT_GRADE_get, Swig_var_ReferenceEntityType_NORTH_AMERICAN_INVESTMENT_GRADE_set);
  SWIG_addvarlink(globals, "ReferenceEntityType_SINGAPOREAN", Swig_var_ReferenceEntityType_SINGAPOREAN_get, Swig_var_ReferenceEntityType_SINGAPOREAN_set);
  SWIG_addvarlink(globals, "ReferenceEntityType_WESTERN_EUROPEAN", Swig_var_ReferenceEntityType_WESTERN_EUROPEAN_get, Swig_var_ReferenceEntityType_WESTERN_EUROPEAN_set);
  SWIG_addvarlink(globals, "ReferenceEntityType_WESTERN_EUROPEAN_INSURANCE", Swig_var_ReferenceEntityType_WESTERN_EUROPEAN_INSURANCE_get, Swig_var_ReferenceEntityType_WESTERN_EUROPEAN_INSURANCE_set);
  SWIG_addvarlink(globals, "BlockTrdAllocIndicator_BLOCK_TO_BE_ALLOCATED", Swig_var_BlockTrdAllocIndicator_BLOCK_TO_BE_ALLOCATED_get, Swig_var_BlockTrdAllocIndicator_BLOCK_TO_BE_ALLOCATED_set);
  SWIG_addvarlink(globals, "BlockTrdAllocIndicator_BLOCK_NOT_TO_BE_ALLOCATED", Swig_var_BlockTrdAllocIndicator_BLOCK_NOT_TO_BE_ALLOCATED_get, Swig_var_BlockTrdAllocIndicator_BLOCK_NOT_TO_BE_ALLOCATED_set);
  SWIG_addvarlink(globals, "BlockTrdAllocIndicator_ALLOCATED_TRADE", Swig_var_BlockTrdAllocIndicator_ALLOCATED_TRADE_get, Swig_var_BlockTrdAllocIndicator_ALLOCATED_TRADE_set);
  SWIG_addvarlink(globals, "UnderlyingObligationType_BOND", Swig_var_UnderlyingObligationType_BOND_get, Swig_var_UnderlyingObligationType_BOND_set);
  SWIG_addvarlink(globals, "UnderlyingObligationType_CONVERTIBLE_BOND", Swig_var_UnderlyingObligationType_CONVERTIBLE_BOND_get, Swig_var_UnderlyingObligationType_CONVERTIBLE_BOND_set);
  SWIG_addvarlink(globals, "UnderlyingObligationType_MORTGAGE", Swig_var_UnderlyingObligationType_MORTGAGE_get, Swig_var_UnderlyingObligationType_MORTGAGE_set);
  SWIG_addvarlink(globals, "UnderlyingObligationType_LOAN", Swig_var_UnderlyingObligationType_LOAN_get, Swig_var_UnderlyingObligationType_LOAN_set);
  SWIG_addvarlink(globals, "CashSettlQuoteMethod_BID", Swig_var_CashSettlQuoteMethod_BID_get, Swig_var_CashSettlQuoteMethod_BID_set);
  SWIG_addvarlink(globals, "CashSettlQuoteMethod_MID", Swig_var_CashSettlQuoteMethod_MID_get, Swig_var_CashSettlQuoteMethod_MID_set);
  SWIG_addvarlink(globals, "CashSettlQuoteMethod_OFFER", Swig_var_CashSettlQuoteMethod_OFFER_get, Swig_var_CashSettlQuoteMethod_OFFER_set);
  SWIG_addvarlink(globals, "CashSettlValuationMethod_MARKET", Swig_var_CashSettlValuationMethod_MARKET_get, Swig_var_CashSettlValuationMethod_MARKET_set);
  SWIG_addvarlink(globals, "CashSettlValuationMethod_HIGHEST", Swig_var_CashSettlValuationMethod_HIGHEST_get, Swig_var_CashSettlValuationMethod_HIGHEST_set);
  SWIG_addvarlink(globals, "CashSettlValuationMethod_AVERAGE_MARKET", Swig_var_CashSettlValuationMethod_AVERAGE_MARKET_get, Swig_var_CashSettlValuationMethod_AVERAGE_MARKET_set);
  SWIG_addvarlink(globals, "CashSettlValuationMethod_AVERAGE_HIGHEST", Swig_var_CashSettlValuationMethod_AVERAGE_HIGHEST_get, Swig_var_CashSettlValuationMethod_AVERAGE_HIGHEST_set);
  SWIG_addvarlink(globals, "CashSettlValuationMethod_BLENDED_MARKET", Swig_var_CashSettlValuationMethod_BLENDED_MARKET_get, Swig_var_CashSettlValuationMethod_BLENDED_MARKET_set);
  SWIG_addvarlink(globals, "CashSettlValuationMethod_BLENDED_HIGHEST", Swig_var_CashSettlValuationMethod_BLENDED_HIGHEST_get, Swig_var_CashSettlValuationMethod_BLENDED_HIGHEST_set);
  SWIG_addvarlink(globals, "CashSettlValuationMethod_AVERAGE_BLENDED_MARKET", Swig_var_CashSettlValuationMethod_AVERAGE_BLENDED_MARKET_get, Swig_var_CashSettlValuationMethod_AVERAGE_BLENDED_MARKET_set);
  SWIG_addvarlink(globals, "CashSettlValuationMethod_AVERAGE_BLENDED_HIGHEST", Swig_var_CashSettlValuationMethod_AVERAGE_BLENDED_HIGHEST_get, Swig_var_CashSettlValuationMethod_AVERAGE_BLENDED_HIGHEST_set);
  SWIG_addvarlink(globals, "StreamType_PAYMENT_CASH_SETTLEMENT", Swig_var_StreamType_PAYMENT_CASH_SETTLEMENT_get, Swig_var_StreamType_PAYMENT_CASH_SETTLEMENT_set);
  SWIG_addvarlink(globals, "StreamType_PHYSICAL_DELIVERY", Swig_var_StreamType_PHYSICAL_DELIVERY_get, Swig_var_StreamType_PHYSICAL_DELIVERY_set);
  SWIG_addvarlink(globals, "ProvisionType_MANDATORY_EARLY_TERMINATION", Swig_var_ProvisionType_MANDATORY_EARLY_TERMINATION_get, Swig_var_ProvisionType_MANDATORY_EARLY_TERMINATION_set);
  SWIG_addvarlink(globals, "ProvisionType_OPTIONAL_EARLY_TERMINATION", Swig_var_ProvisionType_OPTIONAL_EARLY_TERMINATION_get, Swig_var_ProvisionType_OPTIONAL_EARLY_TERMINATION_set);
  SWIG_addvarlink(globals, "ProvisionType_CANCELABLE", Swig_var_ProvisionType_CANCELABLE_get, Swig_var_ProvisionType_CANCELABLE_set);
  SWIG_addvarlink(globals, "ProvisionType_EXTENDABLE", Swig_var_ProvisionType_EXTENDABLE_get, Swig_var_ProvisionType_EXTENDABLE_set);
  SWIG_addvarlink(globals, "ProvisionType_MUTUAL_EARLY_TERMINATION", Swig_var_ProvisionType_MUTUAL_EARLY_TERMINATION_get, Swig_var_ProvisionType_MUTUAL_EARLY_TERMINATION_set);
  SWIG_addvarlink(globals, "ProvisionType_EVERGREEN", Swig_var_ProvisionType_EVERGREEN_get, Swig_var_ProvisionType_EVERGREEN_set);
  SWIG_addvarlink(globals, "ProvisionType_CALLABLE", Swig_var_ProvisionType_CALLABLE_get, Swig_var_ProvisionType_CALLABLE_set);
  SWIG_addvarlink(globals, "ProvisionType_PUTTABLE", Swig_var_ProvisionType_PUTTABLE_get, Swig_var_ProvisionType_PUTTABLE_set);
  SWIG_addvarlink(globals, "ProvisionDateTenorUnit_DAY", Swig_var_ProvisionDateTenorUnit_DAY_get, Swig_var_ProvisionDateTenorUnit_DAY_set);
  SWIG_addvarlink(globals, "ProvisionDateTenorUnit_WEEK", Swig_var_ProvisionDateTenorUnit_WEEK_get, Swig_var_ProvisionDateTenorUnit_WEEK_set);
  SWIG_addvarlink(globals, "ProvisionDateTenorUnit_MONTH", Swig_var_ProvisionDateTenorUnit_MONTH_get, Swig_var_ProvisionDateTenorUnit_MONTH_set);
  SWIG_addvarlink(globals, "ProvisionDateTenorUnit_YEAR", Swig_var_ProvisionDateTenorUnit_YEAR_get, Swig_var_ProvisionDateTenorUnit_YEAR_set);
  SWIG_addvarlink(globals, "ProvisionCalculationAgent_EXERCISING_PARTY", Swig_var_ProvisionCalculationAgent_EXERCISING_PARTY_get, Swig_var_ProvisionCalculationAgent_EXERCISING_PARTY_set);
  SWIG_addvarlink(globals, "ProvisionCalculationAgent_NON_EXERCISING_PARTY", Swig_var_ProvisionCalculationAgent_NON_EXERCISING_PARTY_get, Swig_var_ProvisionCalculationAgent_NON_EXERCISING_PARTY_set);
  SWIG_addvarlink(globals, "ProvisionCalculationAgent_MASTER_AGREEENT", Swig_var_ProvisionCalculationAgent_MASTER_AGREEENT_get, Swig_var_ProvisionCalculationAgent_MASTER_AGREEENT_set);
  SWIG_addvarlink(globals, "ProvisionCalculationAgent_SUPPLEMENT", Swig_var_ProvisionCalculationAgent_SUPPLEMENT_get, Swig_var_ProvisionCalculationAgent_SUPPLEMENT_set);
  SWIG_addvarlink(globals, "ProvisionOptionSinglePartyBuyerSide_BUY", Swig_var_ProvisionOptionSinglePartyBuyerSide_BUY_get, Swig_var_ProvisionOptionSinglePartyBuyerSide_BUY_set);
  SWIG_addvarlink(globals, "ProvisionOptionSinglePartyBuyerSide_SELL", Swig_var_ProvisionOptionSinglePartyBuyerSide_SELL_get, Swig_var_ProvisionOptionSinglePartyBuyerSide_SELL_set);
  SWIG_addvarlink(globals, "ProvisionCashSettlMethod_CASH_PRICE", Swig_var_ProvisionCashSettlMethod_CASH_PRICE_get, Swig_var_ProvisionCashSettlMethod_CASH_PRICE_set);
  SWIG_addvarlink(globals, "ProvisionCashSettlMethod_CASH_PRICE_ALTERNATE", Swig_var_ProvisionCashSettlMethod_CASH_PRICE_ALTERNATE_get, Swig_var_ProvisionCashSettlMethod_CASH_PRICE_ALTERNATE_set);
  SWIG_addvarlink(globals, "ProvisionCashSettlMethod_PAR_YIELD_CURVE_ADJUSTED", Swig_var_ProvisionCashSettlMethod_PAR_YIELD_CURVE_ADJUSTED_get, Swig_var_ProvisionCashSettlMethod_PAR_YIELD_CURVE_ADJUSTED_set);
  SWIG_addvarlink(globals, "ProvisionCashSettlMethod_ZERO_COUPON_YIELD_CURVE_ADJUSTED", Swig_var_ProvisionCashSettlMethod_ZERO_COUPON_YIELD_CURVE_ADJUSTED_get, Swig_var_ProvisionCashSettlMethod_ZERO_COUPON_YIELD_CURVE_ADJUSTED_set);
  SWIG_addvarlink(globals, "ProvisionCashSettlMethod_PAR_YIELD_CURVE_UNADJUSTED", Swig_var_ProvisionCashSettlMethod_PAR_YIELD_CURVE_UNADJUSTED_get, Swig_var_ProvisionCashSettlMethod_PAR_YIELD_CURVE_UNADJUSTED_set);
  SWIG_addvarlink(globals, "ProvisionCashSettlMethod_CROSS_CURRENCY", Swig_var_ProvisionCashSettlMethod_CROSS_CURRENCY_get, Swig_var_ProvisionCashSettlMethod_CROSS_CURRENCY_set);
  SWIG_addvarlink(globals, "ProvisionCashSettlMethod_COLLATERALIZED_PRICE", Swig_var_ProvisionCashSettlMethod_COLLATERALIZED_PRICE_get, Swig_var_ProvisionCashSettlMethod_COLLATERALIZED_PRICE_set);
  SWIG_addvarlink(globals, "ProvisionCashSettlQuoteType_BID", Swig_var_ProvisionCashSettlQuoteType_BID_get, Swig_var_ProvisionCashSettlQuoteType_BID_set);
  SWIG_addvarlink(globals, "ProvisionCashSettlQuoteType_MID", Swig_var_ProvisionCashSettlQuoteType_MID_get, Swig_var_ProvisionCashSettlQuoteType_MID_set);
  SWIG_addvarlink(globals, "ProvisionCashSettlQuoteType_OFFER", Swig_var_ProvisionCashSettlQuoteType_OFFER_get, Swig_var_ProvisionCashSettlQuoteType_OFFER_set);
  SWIG_addvarlink(globals, "ProvisionCashSettlQuoteType_EXERCISING_PARTY_PAYS", Swig_var_ProvisionCashSettlQuoteType_EXERCISING_PARTY_PAYS_get, Swig_var_ProvisionCashSettlQuoteType_EXERCISING_PARTY_PAYS_set);
  SWIG_addvarlink(globals, "ProvisionOptionExerciseEarliestDateOffsetUnit_DAY", Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_DAY_get, Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_DAY_set);
  SWIG_addvarlink(globals, "ProvisionOptionExerciseEarliestDateOffsetUnit_WEEK", Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_WEEK_get, Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_WEEK_set);
  SWIG_addvarlink(globals, "ProvisionOptionExerciseEarliestDateOffsetUnit_MONTH", Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_MONTH_get, Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_MONTH_set);
  SWIG_addvarlink(globals, "ProvisionOptionExerciseEarliestDateOffsetUnit_YEAR", Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_YEAR_get, Swig_var_ProvisionOptionExerciseEarliestDateOffsetUnit_YEAR_set);
  SWIG_addvarlink(globals, "ProvisionOptionExerciseFixedDateType_UNADJUSTED", Swig_var_ProvisionOptionExerciseFixedDateType_UNADJUSTED_get, Swig_var_ProvisionOptionExerciseFixedDateType_UNADJUSTED_set);
  SWIG_addvarlink(globals, "ProvisionOptionExerciseFixedDateType_ADJUSTED", Swig_var_ProvisionOptionExerciseFixedDateType_ADJUSTED_get, Swig_var_ProvisionOptionExerciseFixedDateType_ADJUSTED_set);
  SWIG_addvarlink(globals, "ProvisionCashSettlPaymentDateType_UNADJUSTED", Swig_var_ProvisionCashSettlPaymentDateType_UNADJUSTED_get, Swig_var_ProvisionCashSettlPaymentDateType_UNADJUSTED_set);
  SWIG_addvarlink(globals, "ProvisionCashSettlPaymentDateType_ADJUSTED", Swig_var_ProvisionCashSettlPaymentDateType_ADJUSTED_get, Swig_var_ProvisionCashSettlPaymentDateType_ADJUSTED_set);
  SWIG_addvarlink(globals, "ProtectionTermEventUnit_DAY", Swig_var_ProtectionTermEventUnit_DAY_get, Swig_var_ProtectionTermEventUnit_DAY_set);
  SWIG_addvarlink(globals, "ProtectionTermEventUnit_WEEK", Swig_var_ProtectionTermEventUnit_WEEK_get, Swig_var_ProtectionTermEventUnit_WEEK_set);
  SWIG_addvarlink(globals, "ProtectionTermEventUnit_MONTH", Swig_var_ProtectionTermEventUnit_MONTH_get, Swig_var_ProtectionTermEventUnit_MONTH_set);
  SWIG_addvarlink(globals, "ProtectionTermEventUnit_YEAR", Swig_var_ProtectionTermEventUnit_YEAR_get, Swig_var_ProtectionTermEventUnit_YEAR_set);
  SWIG_addvarlink(globals, "ProtectionTermEventDayType_BUSINESS", Swig_var_ProtectionTermEventDayType_BUSINESS_get, Swig_var_ProtectionTermEventDayType_BUSINESS_set);
  SWIG_addvarlink(globals, "ProtectionTermEventDayType_CALENDAR", Swig_var_ProtectionTermEventDayType_CALENDAR_get, Swig_var_ProtectionTermEventDayType_CALENDAR_set);
  SWIG_addvarlink(globals, "ProtectionTermEventDayType_COMMODITY_BUSINESS", Swig_var_ProtectionTermEventDayType_COMMODITY_BUSINESS_get, Swig_var_ProtectionTermEventDayType_COMMODITY_BUSINESS_set);
  SWIG_addvarlink(globals, "ProtectionTermEventDayType_CURRENCY_BUSINESS", Swig_var_ProtectionTermEventDayType_CURRENCY_BUSINESS_get, Swig_var_ProtectionTermEventDayType_CURRENCY_BUSINESS_set);
  SWIG_addvarlink(globals, "ProtectionTermEventDayType_EXCHANGE_BUSINESS", Swig_var_ProtectionTermEventDayType_EXCHANGE_BUSINESS_get, Swig_var_ProtectionTermEventDayType_EXCHANGE_BUSINESS_set);
  SWIG_addvarlink(globals, "ProtectionTermEventDayType_SCHEDULED_TRADING_DAY", Swig_var_ProtectionTermEventDayType_SCHEDULED_TRADING_DAY_get, Swig_var_ProtectionTermEventDayType_SCHEDULED_TRADING_DAY_set);
  SWIG_addvarlink(globals, "ProtectionTermEventQualifier_RESTRUCTURING_MULTIPLE_HOLDING_OBLIGATIONS", Swig_var_ProtectionTermEventQualifier_RESTRUCTURING_MULTIPLE_HOLDING_OBLIGATIONS_get, Swig_var_ProtectionTermEventQualifier_RESTRUCTURING_MULTIPLE_HOLDING_OBLIGATIONS_set);
  SWIG_addvarlink(globals, "ProtectionTermEventQualifier_RESTRUCTURING_MULTIPLE_CREDIT_EVENT_NOTICES", Swig_var_ProtectionTermEventQualifier_RESTRUCTURING_MULTIPLE_CREDIT_EVENT_NOTICES_get, Swig_var_ProtectionTermEventQualifier_RESTRUCTURING_MULTIPLE_CREDIT_EVENT_NOTICES_set);
  SWIG_addvarlink(globals, "ProtectionTermEventQualifier_FLOATING_RATE_INTEREST_SHORTFALL", Swig_var_ProtectionTermEventQualifier_FLOATING_RATE_INTEREST_SHORTFALL_get, Swig_var_ProtectionTermEventQualifier_FLOATING_RATE_INTEREST_SHORTFALL_set);
  SWIG_addvarlink(globals, "PaymentType_BROKERAGE", Swig_var_PaymentType_BROKERAGE_get, Swig_var_PaymentType_BROKERAGE_set);
  SWIG_addvarlink(globals, "PaymentType_UPFRONT_FEE", Swig_var_PaymentType_UPFRONT_FEE_get, Swig_var_PaymentType_UPFRONT_FEE_set);
  SWIG_addvarlink(globals, "PaymentType_INDEPENDENT_AMOUNT_COLLATERAL", Swig_var_PaymentType_INDEPENDENT_AMOUNT_COLLATERAL_get, Swig_var_PaymentType_INDEPENDENT_AMOUNT_COLLATERAL_set);
  SWIG_addvarlink(globals, "PaymentType_PRINCIPAL_EXCHANGE", Swig_var_PaymentType_PRINCIPAL_EXCHANGE_get, Swig_var_PaymentType_PRINCIPAL_EXCHANGE_set);
  SWIG_addvarlink(globals, "PaymentType_NOVATION_TERMINATION", Swig_var_PaymentType_NOVATION_TERMINATION_get, Swig_var_PaymentType_NOVATION_TERMINATION_set);
  SWIG_addvarlink(globals, "PaymentType_EARLY_TERMINATION_PROVISION", Swig_var_PaymentType_EARLY_TERMINATION_PROVISION_get, Swig_var_PaymentType_EARLY_TERMINATION_PROVISION_set);
  SWIG_addvarlink(globals, "PaymentType_CANCELABLE_PROVISION", Swig_var_PaymentType_CANCELABLE_PROVISION_get, Swig_var_PaymentType_CANCELABLE_PROVISION_set);
  SWIG_addvarlink(globals, "PaymentType_EXTENDIBLE_PROVISION", Swig_var_PaymentType_EXTENDIBLE_PROVISION_get, Swig_var_PaymentType_EXTENDIBLE_PROVISION_set);
  SWIG_addvarlink(globals, "PaymentType_CAP_RATE_PROVISION", Swig_var_PaymentType_CAP_RATE_PROVISION_get, Swig_var_PaymentType_CAP_RATE_PROVISION_set);
  SWIG_addvarlink(globals, "PaymentType_FLOOR_RATE_PROVISION", Swig_var_PaymentType_FLOOR_RATE_PROVISION_get, Swig_var_PaymentType_FLOOR_RATE_PROVISION_set);
  SWIG_addvarlink(globals, "PaymentType_OPTION_PREMIUM", Swig_var_PaymentType_OPTION_PREMIUM_get, Swig_var_PaymentType_OPTION_PREMIUM_set);
  SWIG_addvarlink(globals, "PaymentType_SETTLEMENT_PAYMENT", Swig_var_PaymentType_SETTLEMENT_PAYMENT_get, Swig_var_PaymentType_SETTLEMENT_PAYMENT_set);
  SWIG_addvarlink(globals, "PaymentType_CASH_SETTL", Swig_var_PaymentType_CASH_SETTL_get, Swig_var_PaymentType_CASH_SETTL_set);
  SWIG_addvarlink(globals, "PaymentType_SECURITY_LENDING", Swig_var_PaymentType_SECURITY_LENDING_get, Swig_var_PaymentType_SECURITY_LENDING_set);
  SWIG_addvarlink(globals, "PaymentType_REBATE", Swig_var_PaymentType_REBATE_get, Swig_var_PaymentType_REBATE_set);
  SWIG_addvarlink(globals, "PaymentType_OTHER", Swig_var_PaymentType_OTHER_get, Swig_var_PaymentType_OTHER_set);
  SWIG_addvarlink(globals, "PaymentPaySide_BUY", Swig_var_PaymentPaySide_BUY_get, Swig_var_PaymentPaySide_BUY_set);
  SWIG_addvarlink(globals, "PaymentPaySide_SELL", Swig_var_PaymentPaySide_SELL_get, Swig_var_PaymentPaySide_SELL_set);
  SWIG_addvarlink(globals, "PaymentSettlStyle_STANDARD", Swig_var_PaymentSettlStyle_STANDARD_get, Swig_var_PaymentSettlStyle_STANDARD_set);
  SWIG_addvarlink(globals, "PaymentSettlStyle_NET", Swig_var_PaymentSettlStyle_NET_get, Swig_var_PaymentSettlStyle_NET_set);
  SWIG_addvarlink(globals, "PaymentSettlStyle_STANDARDF_NET", Swig_var_PaymentSettlStyle_STANDARDF_NET_get, Swig_var_PaymentSettlStyle_STANDARDF_NET_set);
  SWIG_addvarlink(globals, "PaymentStreamType_PERIODIC", Swig_var_PaymentStreamType_PERIODIC_get, Swig_var_PaymentStreamType_PERIODIC_set);
  SWIG_addvarlink(globals, "PaymentStreamType_INITIAL", Swig_var_PaymentStreamType_INITIAL_get, Swig_var_PaymentStreamType_INITIAL_set);
  SWIG_addvarlink(globals, "PaymentStreamType_SINGLE", Swig_var_PaymentStreamType_SINGLE_get, Swig_var_PaymentStreamType_SINGLE_set);
  SWIG_addvarlink(globals, "PaymentStreamType_DIVIDEND", Swig_var_PaymentStreamType_DIVIDEND_get, Swig_var_PaymentStreamType_DIVIDEND_set);
  SWIG_addvarlink(globals, "PaymentStreamType_INTEREST", Swig_var_PaymentStreamType_INTEREST_get, Swig_var_PaymentStreamType_INTEREST_set);
  SWIG_addvarlink(globals, "PaymentStreamType_DIVIDEND_RETURN", Swig_var_PaymentStreamType_DIVIDEND_RETURN_get, Swig_var_PaymentStreamType_DIVIDEND_RETURN_set);
  SWIG_addvarlink(globals, "PaymentStreamType_PRICE_RETURN", Swig_var_PaymentStreamType_PRICE_RETURN_get, Swig_var_PaymentStreamType_PRICE_RETURN_set);
  SWIG_addvarlink(globals, "PaymentStreamType_TOTAL_RETURN", Swig_var_PaymentStreamType_TOTAL_RETURN_get, Swig_var_PaymentStreamType_TOTAL_RETURN_set);
  SWIG_addvarlink(globals, "PaymentStreamType_VARIANCE", Swig_var_PaymentStreamType_VARIANCE_get, Swig_var_PaymentStreamType_VARIANCE_set);
  SWIG_addvarlink(globals, "PaymentStreamType_CORRELATION", Swig_var_PaymentStreamType_CORRELATION_get, Swig_var_PaymentStreamType_CORRELATION_set);
  SWIG_addvarlink(globals, "PaymentStreamDiscountType_STANDARD", Swig_var_PaymentStreamDiscountType_STANDARD_get, Swig_var_PaymentStreamDiscountType_STANDARD_set);
  SWIG_addvarlink(globals, "PaymentStreamDiscountType_FRA", Swig_var_PaymentStreamDiscountType_FRA_get, Swig_var_PaymentStreamDiscountType_FRA_set);
  SWIG_addvarlink(globals, "PaymentStreamCompoundingMethod_NONE", Swig_var_PaymentStreamCompoundingMethod_NONE_get, Swig_var_PaymentStreamCompoundingMethod_NONE_set);
  SWIG_addvarlink(globals, "PaymentStreamCompoundingMethod_FLAT", Swig_var_PaymentStreamCompoundingMethod_FLAT_get, Swig_var_PaymentStreamCompoundingMethod_FLAT_set);
  SWIG_addvarlink(globals, "PaymentStreamCompoundingMethod_STRAIGHT", Swig_var_PaymentStreamCompoundingMethod_STRAIGHT_get, Swig_var_PaymentStreamCompoundingMethod_STRAIGHT_set);
  SWIG_addvarlink(globals, "PaymentStreamCompoundingMethod_SPREAD_EXCLUSIVE", Swig_var_PaymentStreamCompoundingMethod_SPREAD_EXCLUSIVE_get, Swig_var_PaymentStreamCompoundingMethod_SPREAD_EXCLUSIVE_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentFrequencyUnit_DAY", Swig_var_PaymentStreamPaymentFrequencyUnit_DAY_get, Swig_var_PaymentStreamPaymentFrequencyUnit_DAY_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentFrequencyUnit_WEEK", Swig_var_PaymentStreamPaymentFrequencyUnit_WEEK_get, Swig_var_PaymentStreamPaymentFrequencyUnit_WEEK_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentFrequencyUnit_MONTH", Swig_var_PaymentStreamPaymentFrequencyUnit_MONTH_get, Swig_var_PaymentStreamPaymentFrequencyUnit_MONTH_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentFrequencyUnit_YEAR", Swig_var_PaymentStreamPaymentFrequencyUnit_YEAR_get, Swig_var_PaymentStreamPaymentFrequencyUnit_YEAR_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentFrequencyUnit_TERM", Swig_var_PaymentStreamPaymentFrequencyUnit_TERM_get, Swig_var_PaymentStreamPaymentFrequencyUnit_TERM_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentDateOffsetUnit_DAY", Swig_var_PaymentStreamPaymentDateOffsetUnit_DAY_get, Swig_var_PaymentStreamPaymentDateOffsetUnit_DAY_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentDateOffsetUnit_WEEK", Swig_var_PaymentStreamPaymentDateOffsetUnit_WEEK_get, Swig_var_PaymentStreamPaymentDateOffsetUnit_WEEK_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentDateOffsetUnit_MONTH", Swig_var_PaymentStreamPaymentDateOffsetUnit_MONTH_get, Swig_var_PaymentStreamPaymentDateOffsetUnit_MONTH_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentDateOffsetUnit_YEAR", Swig_var_PaymentStreamPaymentDateOffsetUnit_YEAR_get, Swig_var_PaymentStreamPaymentDateOffsetUnit_YEAR_set);
  SWIG_addvarlink(globals, "PaymentStreamResetWeeklyRollConvention_MONDAY", Swig_var_PaymentStreamResetWeeklyRollConvention_MONDAY_get, Swig_var_PaymentStreamResetWeeklyRollConvention_MONDAY_set);
  SWIG_addvarlink(globals, "PaymentStreamResetWeeklyRollConvention_TUESDAY", Swig_var_PaymentStreamResetWeeklyRollConvention_TUESDAY_get, Swig_var_PaymentStreamResetWeeklyRollConvention_TUESDAY_set);
  SWIG_addvarlink(globals, "PaymentStreamResetWeeklyRollConvention_WEDNESDAY", Swig_var_PaymentStreamResetWeeklyRollConvention_WEDNESDAY_get, Swig_var_PaymentStreamResetWeeklyRollConvention_WEDNESDAY_set);
  SWIG_addvarlink(globals, "PaymentStreamResetWeeklyRollConvention_THURSDAY", Swig_var_PaymentStreamResetWeeklyRollConvention_THURSDAY_get, Swig_var_PaymentStreamResetWeeklyRollConvention_THURSDAY_set);
  SWIG_addvarlink(globals, "PaymentStreamResetWeeklyRollConvention_FRIDAY", Swig_var_PaymentStreamResetWeeklyRollConvention_FRIDAY_get, Swig_var_PaymentStreamResetWeeklyRollConvention_FRIDAY_set);
  SWIG_addvarlink(globals, "PaymentStreamResetWeeklyRollConvention_SATURDAY", Swig_var_PaymentStreamResetWeeklyRollConvention_SATURDAY_get, Swig_var_PaymentStreamResetWeeklyRollConvention_SATURDAY_set);
  SWIG_addvarlink(globals, "PaymentStreamResetWeeklyRollConvention_SUNDAY", Swig_var_PaymentStreamResetWeeklyRollConvention_SUNDAY_get, Swig_var_PaymentStreamResetWeeklyRollConvention_SUNDAY_set);
  SWIG_addvarlink(globals, "PaymentStreamRateIndexSource_BLOOMBERG", Swig_var_PaymentStreamRateIndexSource_BLOOMBERG_get, Swig_var_PaymentStreamRateIndexSource_BLOOMBERG_set);
  SWIG_addvarlink(globals, "PaymentStreamRateIndexSource_REUTERS", Swig_var_PaymentStreamRateIndexSource_REUTERS_get, Swig_var_PaymentStreamRateIndexSource_REUTERS_set);
  SWIG_addvarlink(globals, "PaymentStreamRateIndexSource_TELERATE", Swig_var_PaymentStreamRateIndexSource_TELERATE_get, Swig_var_PaymentStreamRateIndexSource_TELERATE_set);
  SWIG_addvarlink(globals, "PaymentStreamRateIndexSource_OTHER", Swig_var_PaymentStreamRateIndexSource_OTHER_get, Swig_var_PaymentStreamRateIndexSource_OTHER_set);
  SWIG_addvarlink(globals, "PaymentStreamRateIndexCurveUnit_DAY", Swig_var_PaymentStreamRateIndexCurveUnit_DAY_get, Swig_var_PaymentStreamRateIndexCurveUnit_DAY_set);
  SWIG_addvarlink(globals, "PaymentStreamRateIndexCurveUnit_WEEK", Swig_var_PaymentStreamRateIndexCurveUnit_WEEK_get, Swig_var_PaymentStreamRateIndexCurveUnit_WEEK_set);
  SWIG_addvarlink(globals, "PaymentStreamRateIndexCurveUnit_MONTH", Swig_var_PaymentStreamRateIndexCurveUnit_MONTH_get, Swig_var_PaymentStreamRateIndexCurveUnit_MONTH_set);
  SWIG_addvarlink(globals, "PaymentStreamRateIndexCurveUnit_YEAR", Swig_var_PaymentStreamRateIndexCurveUnit_YEAR_get, Swig_var_PaymentStreamRateIndexCurveUnit_YEAR_set);
  SWIG_addvarlink(globals, "PaymentStreamRateSpreadPositionType_SHORT", Swig_var_PaymentStreamRateSpreadPositionType_SHORT_get, Swig_var_PaymentStreamRateSpreadPositionType_SHORT_set);
  SWIG_addvarlink(globals, "PaymentStreamRateSpreadPositionType_LONG", Swig_var_PaymentStreamRateSpreadPositionType_LONG_get, Swig_var_PaymentStreamRateSpreadPositionType_LONG_set);
  SWIG_addvarlink(globals, "PaymentStreamRateTreatment_BOND_EQUIVALENT_YIELD", Swig_var_PaymentStreamRateTreatment_BOND_EQUIVALENT_YIELD_get, Swig_var_PaymentStreamRateTreatment_BOND_EQUIVALENT_YIELD_set);
  SWIG_addvarlink(globals, "PaymentStreamRateTreatment_MONEY_MARKET_YIELD", Swig_var_PaymentStreamRateTreatment_MONEY_MARKET_YIELD_get, Swig_var_PaymentStreamRateTreatment_MONEY_MARKET_YIELD_set);
  SWIG_addvarlink(globals, "PaymentStreamCapRateBuySide_BUYER", Swig_var_PaymentStreamCapRateBuySide_BUYER_get, Swig_var_PaymentStreamCapRateBuySide_BUYER_set);
  SWIG_addvarlink(globals, "PaymentStreamCapRateBuySide_SELLER", Swig_var_PaymentStreamCapRateBuySide_SELLER_get, Swig_var_PaymentStreamCapRateBuySide_SELLER_set);
  SWIG_addvarlink(globals, "PaymentStreamFloorRateBuySide_BUYER", Swig_var_PaymentStreamFloorRateBuySide_BUYER_get, Swig_var_PaymentStreamFloorRateBuySide_BUYER_set);
  SWIG_addvarlink(globals, "PaymentStreamFloorRateBuySide_SELLER", Swig_var_PaymentStreamFloorRateBuySide_SELLER_get, Swig_var_PaymentStreamFloorRateBuySide_SELLER_set);
  SWIG_addvarlink(globals, "PaymentStreamAveragingMethod_UNWEIGHTED", Swig_var_PaymentStreamAveragingMethod_UNWEIGHTED_get, Swig_var_PaymentStreamAveragingMethod_UNWEIGHTED_set);
  SWIG_addvarlink(globals, "PaymentStreamAveragingMethod_WEIGHTED", Swig_var_PaymentStreamAveragingMethod_WEIGHTED_get, Swig_var_PaymentStreamAveragingMethod_WEIGHTED_set);
  SWIG_addvarlink(globals, "PaymentStreamNegativeRateTreatment_ZERO_INTEREST_RATE_METHOD", Swig_var_PaymentStreamNegativeRateTreatment_ZERO_INTEREST_RATE_METHOD_get, Swig_var_PaymentStreamNegativeRateTreatment_ZERO_INTEREST_RATE_METHOD_set);
  SWIG_addvarlink(globals, "PaymentStreamNegativeRateTreatment_NEGATIVE_INTEREST_RATE_METHOD", Swig_var_PaymentStreamNegativeRateTreatment_NEGATIVE_INTEREST_RATE_METHOD_get, Swig_var_PaymentStreamNegativeRateTreatment_NEGATIVE_INTEREST_RATE_METHOD_set);
  SWIG_addvarlink(globals, "PaymentStreamInflationLagUnit_DAY", Swig_var_PaymentStreamInflationLagUnit_DAY_get, Swig_var_PaymentStreamInflationLagUnit_DAY_set);
  SWIG_addvarlink(globals, "PaymentStreamInflationLagUnit_WEEK", Swig_var_PaymentStreamInflationLagUnit_WEEK_get, Swig_var_PaymentStreamInflationLagUnit_WEEK_set);
  SWIG_addvarlink(globals, "PaymentStreamInflationLagUnit_MONTH", Swig_var_PaymentStreamInflationLagUnit_MONTH_get, Swig_var_PaymentStreamInflationLagUnit_MONTH_set);
  SWIG_addvarlink(globals, "PaymentStreamInflationLagUnit_YEAR", Swig_var_PaymentStreamInflationLagUnit_YEAR_get, Swig_var_PaymentStreamInflationLagUnit_YEAR_set);
  SWIG_addvarlink(globals, "PaymentStreamInflationLagDayType_BUSINESS", Swig_var_PaymentStreamInflationLagDayType_BUSINESS_get, Swig_var_PaymentStreamInflationLagDayType_BUSINESS_set);
  SWIG_addvarlink(globals, "PaymentStreamInflationLagDayType_CALENDAR", Swig_var_PaymentStreamInflationLagDayType_CALENDAR_get, Swig_var_PaymentStreamInflationLagDayType_CALENDAR_set);
  SWIG_addvarlink(globals, "PaymentStreamInflationLagDayType_COMMODITY_BUSINESS", Swig_var_PaymentStreamInflationLagDayType_COMMODITY_BUSINESS_get, Swig_var_PaymentStreamInflationLagDayType_COMMODITY_BUSINESS_set);
  SWIG_addvarlink(globals, "PaymentStreamInflationLagDayType_CURRENCY_BUSINESS", Swig_var_PaymentStreamInflationLagDayType_CURRENCY_BUSINESS_get, Swig_var_PaymentStreamInflationLagDayType_CURRENCY_BUSINESS_set);
  SWIG_addvarlink(globals, "PaymentStreamInflationLagDayType_EXCHANGE_BUSINESS", Swig_var_PaymentStreamInflationLagDayType_EXCHANGE_BUSINESS_get, Swig_var_PaymentStreamInflationLagDayType_EXCHANGE_BUSINESS_set);
  SWIG_addvarlink(globals, "PaymentStreamInflationLagDayType_SCHEDULED_TRADING_DAY", Swig_var_PaymentStreamInflationLagDayType_SCHEDULED_TRADING_DAY_get, Swig_var_PaymentStreamInflationLagDayType_SCHEDULED_TRADING_DAY_set);
  SWIG_addvarlink(globals, "PaymentStreamInflationInterpolationMethod_NONE", Swig_var_PaymentStreamInflationInterpolationMethod_NONE_get, Swig_var_PaymentStreamInflationInterpolationMethod_NONE_set);
  SWIG_addvarlink(globals, "PaymentStreamInflationInterpolationMethod_LINEAR_ZERO_YIELD", Swig_var_PaymentStreamInflationInterpolationMethod_LINEAR_ZERO_YIELD_get, Swig_var_PaymentStreamInflationInterpolationMethod_LINEAR_ZERO_YIELD_set);
  SWIG_addvarlink(globals, "PaymentStreamFRADiscounting_NONE", Swig_var_PaymentStreamFRADiscounting_NONE_get, Swig_var_PaymentStreamFRADiscounting_NONE_set);
  SWIG_addvarlink(globals, "PaymentStreamFRADiscounting_ISDA", Swig_var_PaymentStreamFRADiscounting_ISDA_get, Swig_var_PaymentStreamFRADiscounting_ISDA_set);
  SWIG_addvarlink(globals, "PaymentStreamFRADiscounting_AFMA", Swig_var_PaymentStreamFRADiscounting_AFMA_get, Swig_var_PaymentStreamFRADiscounting_AFMA_set);
  SWIG_addvarlink(globals, "NonDeliverableFixingDateType_UNADJUSTED", Swig_var_NonDeliverableFixingDateType_UNADJUSTED_get, Swig_var_NonDeliverableFixingDateType_UNADJUSTED_set);
  SWIG_addvarlink(globals, "NonDeliverableFixingDateType_ADJUSTED", Swig_var_NonDeliverableFixingDateType_ADJUSTED_get, Swig_var_NonDeliverableFixingDateType_ADJUSTED_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_NOTIONAL", Swig_var_PaymentScheduleType_NOTIONAL_get, Swig_var_PaymentScheduleType_NOTIONAL_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_CASH_FLOW", Swig_var_PaymentScheduleType_CASH_FLOW_get, Swig_var_PaymentScheduleType_CASH_FLOW_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_FX_LINKED_NOTIONAL", Swig_var_PaymentScheduleType_FX_LINKED_NOTIONAL_get, Swig_var_PaymentScheduleType_FX_LINKED_NOTIONAL_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_FIXED_RATE", Swig_var_PaymentScheduleType_FIXED_RATE_get, Swig_var_PaymentScheduleType_FIXED_RATE_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_FUTURE_VALUE_NOTIONAL", Swig_var_PaymentScheduleType_FUTURE_VALUE_NOTIONAL_get, Swig_var_PaymentScheduleType_FUTURE_VALUE_NOTIONAL_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_KNOWN_AMOUNT", Swig_var_PaymentScheduleType_KNOWN_AMOUNT_get, Swig_var_PaymentScheduleType_KNOWN_AMOUNT_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_FLOATING_RATE_MULTIPLIER", Swig_var_PaymentScheduleType_FLOATING_RATE_MULTIPLIER_get, Swig_var_PaymentScheduleType_FLOATING_RATE_MULTIPLIER_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_SPREAD", Swig_var_PaymentScheduleType_SPREAD_get, Swig_var_PaymentScheduleType_SPREAD_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_CAP_RATE", Swig_var_PaymentScheduleType_CAP_RATE_get, Swig_var_PaymentScheduleType_CAP_RATE_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_FLOOR_RATE", Swig_var_PaymentScheduleType_FLOOR_RATE_get, Swig_var_PaymentScheduleType_FLOOR_RATE_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_NON_DELIVERABLE_SETTL_PAYMENT_DATES", Swig_var_PaymentScheduleType_NON_DELIVERABLE_SETTL_PAYMENT_DATES_get, Swig_var_PaymentScheduleType_NON_DELIVERABLE_SETTL_PAYMENT_DATES_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_NON_DELIVERABLE_SETTL_CALCULATION_DATES", Swig_var_PaymentScheduleType_NON_DELIVERABLE_SETTL_CALCULATION_DATES_get, Swig_var_PaymentScheduleType_NON_DELIVERABLE_SETTL_CALCULATION_DATES_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_NON_DELIVERABLE_FX_FIXING_DATES", Swig_var_PaymentScheduleType_NON_DELIVERABLE_FX_FIXING_DATES_get, Swig_var_PaymentScheduleType_NON_DELIVERABLE_FX_FIXING_DATES_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_SETTL_PERIOD_NOTNL", Swig_var_PaymentScheduleType_SETTL_PERIOD_NOTNL_get, Swig_var_PaymentScheduleType_SETTL_PERIOD_NOTNL_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_SETTL_PERIOD_PX", Swig_var_PaymentScheduleType_SETTL_PERIOD_PX_get, Swig_var_PaymentScheduleType_SETTL_PERIOD_PX_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_CALC_PERIOD", Swig_var_PaymentScheduleType_CALC_PERIOD_get, Swig_var_PaymentScheduleType_CALC_PERIOD_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_DIVIDEND_ACCRUAL_RATE_MULTIPLIER", Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_RATE_MULTIPLIER_get, Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_RATE_MULTIPLIER_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_DIVIDEND_ACCRUAL_RATE_SPREAD", Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_RATE_SPREAD_get, Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_RATE_SPREAD_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_DIVIDEND_ACCRUAL_CAP_RATE", Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_CAP_RATE_get, Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_CAP_RATE_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_DIVIDEND_ACCRUAL_FLOOR_RATE", Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_FLOOR_RATE_get, Swig_var_PaymentScheduleType_DIVIDEND_ACCRUAL_FLOOR_RATE_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_COMPOUNDING_RATE_MULTIPLIER", Swig_var_PaymentScheduleType_COMPOUNDING_RATE_MULTIPLIER_get, Swig_var_PaymentScheduleType_COMPOUNDING_RATE_MULTIPLIER_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_COMPOUNDING_RATE_SPREAD", Swig_var_PaymentScheduleType_COMPOUNDING_RATE_SPREAD_get, Swig_var_PaymentScheduleType_COMPOUNDING_RATE_SPREAD_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_COMPOUNDING_CAP_RATE", Swig_var_PaymentScheduleType_COMPOUNDING_CAP_RATE_get, Swig_var_PaymentScheduleType_COMPOUNDING_CAP_RATE_set);
  SWIG_addvarlink(globals, "PaymentScheduleType_COMPOUNDING_FLOOR_RATE", Swig_var_PaymentScheduleType_COMPOUNDING_FLOOR_RATE_get, Swig_var_PaymentScheduleType_COMPOUNDING_FLOOR_RATE_set);
  SWIG_addvarlink(globals, "PaymentScheduleStepRelativeTo_INITIAL", Swig_var_PaymentScheduleStepRelativeTo_INITIAL_get, Swig_var_PaymentScheduleStepRelativeTo_INITIAL_set);
  SWIG_addvarlink(globals, "PaymentScheduleStepRelativeTo_PREVIOUS", Swig_var_PaymentScheduleStepRelativeTo_PREVIOUS_get, Swig_var_PaymentScheduleStepRelativeTo_PREVIOUS_set);
  SWIG_addvarlink(globals, "PaymentStubType_INITIAL", Swig_var_PaymentStubType_INITIAL_get, Swig_var_PaymentStubType_INITIAL_set);
  SWIG_addvarlink(globals, "PaymentStubType_FINAL", Swig_var_PaymentStubType_FINAL_get, Swig_var_PaymentStubType_FINAL_set);
  SWIG_addvarlink(globals, "PaymentStubType_COMPOUNDING_INITIAL", Swig_var_PaymentStubType_COMPOUNDING_INITIAL_get, Swig_var_PaymentStubType_COMPOUNDING_INITIAL_set);
  SWIG_addvarlink(globals, "PaymentStubType_COMPOUNDING_FINAL", Swig_var_PaymentStubType_COMPOUNDING_FINAL_get, Swig_var_PaymentStubType_COMPOUNDING_FINAL_set);
  SWIG_addvarlink(globals, "PaymentStubLength_SHORT", Swig_var_PaymentStubLength_SHORT_get, Swig_var_PaymentStubLength_SHORT_set);
  SWIG_addvarlink(globals, "PaymentStubLength_LONG", Swig_var_PaymentStubLength_LONG_get, Swig_var_PaymentStubLength_LONG_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentDateOffsetDayType_BUSINESS", Swig_var_PaymentStreamPaymentDateOffsetDayType_BUSINESS_get, Swig_var_PaymentStreamPaymentDateOffsetDayType_BUSINESS_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentDateOffsetDayType_CALENDAR", Swig_var_PaymentStreamPaymentDateOffsetDayType_CALENDAR_get, Swig_var_PaymentStreamPaymentDateOffsetDayType_CALENDAR_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentDateOffsetDayType_COMMODITY_BUSINESS", Swig_var_PaymentStreamPaymentDateOffsetDayType_COMMODITY_BUSINESS_get, Swig_var_PaymentStreamPaymentDateOffsetDayType_COMMODITY_BUSINESS_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentDateOffsetDayType_CURRENCY_BUSINESS", Swig_var_PaymentStreamPaymentDateOffsetDayType_CURRENCY_BUSINESS_get, Swig_var_PaymentStreamPaymentDateOffsetDayType_CURRENCY_BUSINESS_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentDateOffsetDayType_EXCHANGE_BUSINESS", Swig_var_PaymentStreamPaymentDateOffsetDayType_EXCHANGE_BUSINESS_get, Swig_var_PaymentStreamPaymentDateOffsetDayType_EXCHANGE_BUSINESS_set);
  SWIG_addvarlink(globals, "PaymentStreamPaymentDateOffsetDayType_SCHEDULED_TRADING_DAY", Swig_var_PaymentStreamPaymentDateOffsetDayType_SCHEDULED_TRADING_DAY_get, Swig_var_PaymentStreamPaymentDateOffsetDayType_SCHEDULED_TRADING_DAY_set);
  SWIG_addvarlink(globals, "BusinessDayConvention_NOT_APPLICABLE", Swig_var_BusinessDayConvention_NOT_APPLICABLE_get, Swig_var_BusinessDayConvention_NOT_APPLICABLE_set);
  SWIG_addvarlink(globals, "BusinessDayConvention_NONE", Swig_var_BusinessDayConvention_NONE_get, Swig_var_BusinessDayConvention_NONE_set);
  SWIG_addvarlink(globals, "BusinessDayConvention_FOLLOWING_DAY", Swig_var_BusinessDayConvention_FOLLOWING_DAY_get, Swig_var_BusinessDayConvention_FOLLOWING_DAY_set);
  SWIG_addvarlink(globals, "BusinessDayConvention_FLOATING_RATE_NOTE", Swig_var_BusinessDayConvention_FLOATING_RATE_NOTE_get, Swig_var_BusinessDayConvention_FLOATING_RATE_NOTE_set);
  SWIG_addvarlink(globals, "BusinessDayConvention_MODIFIED_FOLLOWING_DAY", Swig_var_BusinessDayConvention_MODIFIED_FOLLOWING_DAY_get, Swig_var_BusinessDayConvention_MODIFIED_FOLLOWING_DAY_set);
  SWIG_addvarlink(globals, "BusinessDayConvention_PRECEDING_DAY", Swig_var_BusinessDayConvention_PRECEDING_DAY_get, Swig_var_BusinessDayConvention_PRECEDING_DAY_set);
  SWIG_addvarlink(globals, "BusinessDayConvention_MODIFIED_PRECEDING_DAY", Swig_var_BusinessDayConvention_MODIFIED_PRECEDING_DAY_get, Swig_var_BusinessDayConvention_MODIFIED_PRECEDING_DAY_set);
  SWIG_addvarlink(globals, "BusinessDayConvention_NEAREST_DAY", Swig_var_BusinessDayConvention_NEAREST_DAY_get, Swig_var_BusinessDayConvention_NEAREST_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_FIRST_DAY", Swig_var_DateRollConvention_FIRST_DAY_get, Swig_var_DateRollConvention_FIRST_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_SECOND_DAY", Swig_var_DateRollConvention_SECOND_DAY_get, Swig_var_DateRollConvention_SECOND_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_THIRD_DAY", Swig_var_DateRollConvention_THIRD_DAY_get, Swig_var_DateRollConvention_THIRD_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_FOURTH_DAY", Swig_var_DateRollConvention_FOURTH_DAY_get, Swig_var_DateRollConvention_FOURTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_FIFTH_DAY", Swig_var_DateRollConvention_FIFTH_DAY_get, Swig_var_DateRollConvention_FIFTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_SIXTH_DAY", Swig_var_DateRollConvention_SIXTH_DAY_get, Swig_var_DateRollConvention_SIXTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_SEVENTH_DAY", Swig_var_DateRollConvention_SEVENTH_DAY_get, Swig_var_DateRollConvention_SEVENTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_EIGHTH_DAY", Swig_var_DateRollConvention_EIGHTH_DAY_get, Swig_var_DateRollConvention_EIGHTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_NINTH_DAY", Swig_var_DateRollConvention_NINTH_DAY_get, Swig_var_DateRollConvention_NINTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_TENTH_DAY", Swig_var_DateRollConvention_TENTH_DAY_get, Swig_var_DateRollConvention_TENTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_ELEVENTH_DAY", Swig_var_DateRollConvention_ELEVENTH_DAY_get, Swig_var_DateRollConvention_ELEVENTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_TWELVTH_DAY", Swig_var_DateRollConvention_TWELVTH_DAY_get, Swig_var_DateRollConvention_TWELVTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_THIRTEENTH_DAY", Swig_var_DateRollConvention_THIRTEENTH_DAY_get, Swig_var_DateRollConvention_THIRTEENTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_FORTEENTH_DAY", Swig_var_DateRollConvention_FORTEENTH_DAY_get, Swig_var_DateRollConvention_FORTEENTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_FIFTEENTH_DAY", Swig_var_DateRollConvention_FIFTEENTH_DAY_get, Swig_var_DateRollConvention_FIFTEENTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_SIXTEENTH_DAY", Swig_var_DateRollConvention_SIXTEENTH_DAY_get, Swig_var_DateRollConvention_SIXTEENTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_SEVENTEENTH_DAY", Swig_var_DateRollConvention_SEVENTEENTH_DAY_get, Swig_var_DateRollConvention_SEVENTEENTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_EIGHTEENTH_DAY", Swig_var_DateRollConvention_EIGHTEENTH_DAY_get, Swig_var_DateRollConvention_EIGHTEENTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_NINETEENTH_DAY", Swig_var_DateRollConvention_NINETEENTH_DAY_get, Swig_var_DateRollConvention_NINETEENTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_TWENTIETH_DAY", Swig_var_DateRollConvention_TWENTIETH_DAY_get, Swig_var_DateRollConvention_TWENTIETH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_TWENTY_FIRST_DAY", Swig_var_DateRollConvention_TWENTY_FIRST_DAY_get, Swig_var_DateRollConvention_TWENTY_FIRST_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_TWENTY_SECOND_DAY", Swig_var_DateRollConvention_TWENTY_SECOND_DAY_get, Swig_var_DateRollConvention_TWENTY_SECOND_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_TWENTY_THIRD_DAY", Swig_var_DateRollConvention_TWENTY_THIRD_DAY_get, Swig_var_DateRollConvention_TWENTY_THIRD_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_TWENTY_FOURTH_DAY", Swig_var_DateRollConvention_TWENTY_FOURTH_DAY_get, Swig_var_DateRollConvention_TWENTY_FOURTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_TWENTY_FIFTH_DAY", Swig_var_DateRollConvention_TWENTY_FIFTH_DAY_get, Swig_var_DateRollConvention_TWENTY_FIFTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_TWENTY_SIXTH_DAY", Swig_var_DateRollConvention_TWENTY_SIXTH_DAY_get, Swig_var_DateRollConvention_TWENTY_SIXTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_TWENTY_SEVENTH_DAY", Swig_var_DateRollConvention_TWENTY_SEVENTH_DAY_get, Swig_var_DateRollConvention_TWENTY_SEVENTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_TWENTY_EIGTH_DA28Y", Swig_var_DateRollConvention_TWENTY_EIGTH_DA28Y_get, Swig_var_DateRollConvention_TWENTY_EIGTH_DA28Y_set);
  SWIG_addvarlink(globals, "DateRollConvention_TWENTY_NINTH_DAY", Swig_var_DateRollConvention_TWENTY_NINTH_DAY_get, Swig_var_DateRollConvention_TWENTY_NINTH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_THIRTIETH_DAY", Swig_var_DateRollConvention_THIRTIETH_DAY_get, Swig_var_DateRollConvention_THIRTIETH_DAY_set);
  SWIG_addvarlink(globals, "DateRollConvention_EOM", Swig_var_DateRollConvention_EOM_get, Swig_var_DateRollConvention_EOM_set);
  SWIG_addvarlink(globals, "DateRollConvention_FRN", Swig_var_DateRollConvention_FRN_get, Swig_var_DateRollConvention_FRN_set);
  SWIG_addvarlink(globals, "DateRollConvention_IMM", Swig_var_DateRollConvention_IMM_get, Swig_var_DateRollConvention_IMM_set);
  SWIG_addvarlink(globals, "DateRollConvention_IMMCAD", Swig_var_DateRollConvention_IMMCAD_get, Swig_var_DateRollConvention_IMMCAD_set);
  SWIG_addvarlink(globals, "DateRollConvention_IMMAUD", Swig_var_DateRollConvention_IMMAUD_get, Swig_var_DateRollConvention_IMMAUD_set);
  SWIG_addvarlink(globals, "DateRollConvention_IMMNZD", Swig_var_DateRollConvention_IMMNZD_get, Swig_var_DateRollConvention_IMMNZD_set);
  SWIG_addvarlink(globals, "DateRollConvention_SFE", Swig_var_DateRollConvention_SFE_get, Swig_var_DateRollConvention_SFE_set);
  SWIG_addvarlink(globals, "DateRollConvention_NONE", Swig_var_DateRollConvention_NONE_get, Swig_var_DateRollConvention_NONE_set);
  SWIG_addvarlink(globals, "DateRollConvention_TBILL", Swig_var_DateRollConvention_TBILL_get, Swig_var_DateRollConvention_TBILL_set);
  SWIG_addvarlink(globals, "DateRollConvention_MON", Swig_var_DateRollConvention_MON_get, Swig_var_DateRollConvention_MON_set);
  SWIG_addvarlink(globals, "DateRollConvention_TUE", Swig_var_DateRollConvention_TUE_get, Swig_var_DateRollConvention_TUE_set);
  SWIG_addvarlink(globals, "DateRollConvention_WED", Swig_var_DateRollConvention_WED_get, Swig_var_DateRollConvention_WED_set);
  SWIG_addvarlink(globals, "DateRollConvention_THU", Swig_var_DateRollConvention_THU_get, Swig_var_DateRollConvention_THU_set);
  SWIG_addvarlink(globals, "DateRollConvention_FRI", Swig_var_DateRollConvention_FRI_get, Swig_var_DateRollConvention_FRI_set);
  SWIG_addvarlink(globals, "DateRollConvention_SAT", Swig_var_DateRollConvention_SAT_get, Swig_var_DateRollConvention_SAT_set);
  SWIG_addvarlink(globals, "DateRollConvention_SUN", Swig_var_DateRollConvention_SUN_get, Swig_var_DateRollConvention_SUN_set);
  SWIG_addvarlink(globals, "AttachmentEncodingType_BASE64", Swig_var_AttachmentEncodingType_BASE64_get, Swig_var_AttachmentEncodingType_BASE64_set);
  SWIG_addvarlink(globals, "AttachmentEncodingType_RAW_BINARY", Swig_var_AttachmentEncodingType_RAW_BINARY_get, Swig_var_AttachmentEncodingType_RAW_BINARY_set);
  SWIG_addvarlink(globals, "NegotiationMethod_AUTO_SPOT", Swig_var_NegotiationMethod_AUTO_SPOT_get, Swig_var_NegotiationMethod_AUTO_SPOT_set);
  SWIG_addvarlink(globals, "NegotiationMethod_NEGOTIATED_SPOT", Swig_var_NegotiationMethod_NEGOTIATED_SPOT_get, Swig_var_NegotiationMethod_NEGOTIATED_SPOT_set);
  SWIG_addvarlink(globals, "NegotiationMethod_PHONE_SPOT", Swig_var_NegotiationMethod_PHONE_SPOT_get, Swig_var_NegotiationMethod_PHONE_SPOT_set);
  SWIG_addvarlink(globals, "ComplexEventPeriodType_ASIAN_OUT", Swig_var_ComplexEventPeriodType_ASIAN_OUT_get, Swig_var_ComplexEventPeriodType_ASIAN_OUT_set);
  SWIG_addvarlink(globals, "ComplexEventPeriodType_ASIAN_IN", Swig_var_ComplexEventPeriodType_ASIAN_IN_get, Swig_var_ComplexEventPeriodType_ASIAN_IN_set);
  SWIG_addvarlink(globals, "ComplexEventPeriodType_BARRIER_CAP", Swig_var_ComplexEventPeriodType_BARRIER_CAP_get, Swig_var_ComplexEventPeriodType_BARRIER_CAP_set);
  SWIG_addvarlink(globals, "ComplexEventPeriodType_BARRIER_FLOOR", Swig_var_ComplexEventPeriodType_BARRIER_FLOOR_get, Swig_var_ComplexEventPeriodType_BARRIER_FLOOR_set);
  SWIG_addvarlink(globals, "ComplexEventPeriodType_KNOCK_OUT", Swig_var_ComplexEventPeriodType_KNOCK_OUT_get, Swig_var_ComplexEventPeriodType_KNOCK_OUT_set);
  SWIG_addvarlink(globals, "ComplexEventPeriodType_KNOCK_IN", Swig_var_ComplexEventPeriodType_KNOCK_IN_get, Swig_var_ComplexEventPeriodType_KNOCK_IN_set);
  SWIG_addvarlink(globals, "ComplexEventDateOffsetDayType_BUSINESS", Swig_var_ComplexEventDateOffsetDayType_BUSINESS_get, Swig_var_ComplexEventDateOffsetDayType_BUSINESS_set);
  SWIG_addvarlink(globals, "ComplexEventDateOffsetDayType_CALENDAR", Swig_var_ComplexEventDateOffsetDayType_CALENDAR_get, Swig_var_ComplexEventDateOffsetDayType_CALENDAR_set);
  SWIG_addvarlink(globals, "ComplexEventDateOffsetDayType_COMMODITY_BUSINESS", Swig_var_ComplexEventDateOffsetDayType_COMMODITY_BUSINESS_get, Swig_var_ComplexEventDateOffsetDayType_COMMODITY_BUSINESS_set);
  SWIG_addvarlink(globals, "ComplexEventDateOffsetDayType_CURRENCY_BUSINESS", Swig_var_ComplexEventDateOffsetDayType_CURRENCY_BUSINESS_get, Swig_var_ComplexEventDateOffsetDayType_CURRENCY_BUSINESS_set);
  SWIG_addvarlink(globals, "ComplexEventDateOffsetDayType_EXCHANGE_BUSINESS", Swig_var_ComplexEventDateOffsetDayType_EXCHANGE_BUSINESS_get, Swig_var_ComplexEventDateOffsetDayType_EXCHANGE_BUSINESS_set);
  SWIG_addvarlink(globals, "ComplexEventDateOffsetDayType_SCHEDULED_TRADING_DAY", Swig_var_ComplexEventDateOffsetDayType_SCHEDULED_TRADING_DAY_get, Swig_var_ComplexEventDateOffsetDayType_SCHEDULED_TRADING_DAY_set);
  SWIG_addvarlink(globals, "ComplexOptPayoutTime_CLOSE", Swig_var_ComplexOptPayoutTime_CLOSE_get, Swig_var_ComplexOptPayoutTime_CLOSE_set);
  SWIG_addvarlink(globals, "ComplexOptPayoutTime_OPEN", Swig_var_ComplexOptPayoutTime_OPEN_get, Swig_var_ComplexOptPayoutTime_OPEN_set);
  SWIG_addvarlink(globals, "ComplexOptPayoutTime_OFFICIAL_SETTL", Swig_var_ComplexOptPayoutTime_OFFICIAL_SETTL_get, Swig_var_ComplexOptPayoutTime_OFFICIAL_SETTL_set);
  SWIG_addvarlink(globals, "ComplexOptPayoutTime_VALUATION_TIME", Swig_var_ComplexOptPayoutTime_VALUATION_TIME_get, Swig_var_ComplexOptPayoutTime_VALUATION_TIME_set);
  SWIG_addvarlink(globals, "ComplexOptPayoutTime_EXCAHGNE_SETTL_TIME", Swig_var_ComplexOptPayoutTime_EXCAHGNE_SETTL_TIME_get, Swig_var_ComplexOptPayoutTime_EXCAHGNE_SETTL_TIME_set);
  SWIG_addvarlink(globals, "ComplexOptPayoutTime_DERIVATIVES_CLOSE", Swig_var_ComplexOptPayoutTime_DERIVATIVES_CLOSE_get, Swig_var_ComplexOptPayoutTime_DERIVATIVES_CLOSE_set);
  SWIG_addvarlink(globals, "ComplexOptPayoutTime_AS_SPECIFIED", Swig_var_ComplexOptPayoutTime_AS_SPECIFIED_get, Swig_var_ComplexOptPayoutTime_AS_SPECIFIED_set);
  SWIG_addvarlink(globals, "ComplexEventQuoteBasis_CURRENCY1_PER_CURRENCY2", Swig_var_ComplexEventQuoteBasis_CURRENCY1_PER_CURRENCY2_get, Swig_var_ComplexEventQuoteBasis_CURRENCY1_PER_CURRENCY2_set);
  SWIG_addvarlink(globals, "ComplexEventQuoteBasis_CURRENCY2_PER_CURRENCY1", Swig_var_ComplexEventQuoteBasis_CURRENCY2_PER_CURRENCY1_get, Swig_var_ComplexEventQuoteBasis_CURRENCY2_PER_CURRENCY1_set);
  SWIG_addvarlink(globals, "ComplexEventCreditEventNotifyingParty_SELLER_NOTIFIES", Swig_var_ComplexEventCreditEventNotifyingParty_SELLER_NOTIFIES_get, Swig_var_ComplexEventCreditEventNotifyingParty_SELLER_NOTIFIES_set);
  SWIG_addvarlink(globals, "ComplexEventCreditEventNotifyingParty_BUYER_NOTIFIES", Swig_var_ComplexEventCreditEventNotifyingParty_BUYER_NOTIFIES_get, Swig_var_ComplexEventCreditEventNotifyingParty_BUYER_NOTIFIES_set);
  SWIG_addvarlink(globals, "ComplexEventCreditEventNotifyingParty_SELLER_OR_BUYER_NOTIFIES", Swig_var_ComplexEventCreditEventNotifyingParty_SELLER_OR_BUYER_NOTIFIES_get, Swig_var_ComplexEventCreditEventNotifyingParty_SELLER_OR_BUYER_NOTIFIES_set);
  SWIG_addvarlink(globals, "DeliveryScheduleType_NOTIONAL", Swig_var_DeliveryScheduleType_NOTIONAL_get, Swig_var_DeliveryScheduleType_NOTIONAL_set);
  SWIG_addvarlink(globals, "DeliveryScheduleType_DELIVERY", Swig_var_DeliveryScheduleType_DELIVERY_get, Swig_var_DeliveryScheduleType_DELIVERY_set);
  SWIG_addvarlink(globals, "DeliveryScheduleType_PHYSICAL_SETTL_PERIODS", Swig_var_DeliveryScheduleType_PHYSICAL_SETTL_PERIODS_get, Swig_var_DeliveryScheduleType_PHYSICAL_SETTL_PERIODS_set);
  SWIG_addvarlink(globals, "DeliveryScheduleToleranceType_ABSOLUTE", Swig_var_DeliveryScheduleToleranceType_ABSOLUTE_get, Swig_var_DeliveryScheduleToleranceType_ABSOLUTE_set);
  SWIG_addvarlink(globals, "DeliveryScheduleToleranceType_PERCENTAGE", Swig_var_DeliveryScheduleToleranceType_PERCENTAGE_get, Swig_var_DeliveryScheduleToleranceType_PERCENTAGE_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlFlowType_ALL_TIMES", Swig_var_DeliveryScheduleSettlFlowType_ALL_TIMES_get, Swig_var_DeliveryScheduleSettlFlowType_ALL_TIMES_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlFlowType_ON_PEAK", Swig_var_DeliveryScheduleSettlFlowType_ON_PEAK_get, Swig_var_DeliveryScheduleSettlFlowType_ON_PEAK_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlFlowType_OFF_PEAK", Swig_var_DeliveryScheduleSettlFlowType_OFF_PEAK_get, Swig_var_DeliveryScheduleSettlFlowType_OFF_PEAK_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlFlowType_BASE", Swig_var_DeliveryScheduleSettlFlowType_BASE_get, Swig_var_DeliveryScheduleSettlFlowType_BASE_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlFlowType_BLOCK_HOURS", Swig_var_DeliveryScheduleSettlFlowType_BLOCK_HOURS_get, Swig_var_DeliveryScheduleSettlFlowType_BLOCK_HOURS_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlFlowType_OTHER", Swig_var_DeliveryScheduleSettlFlowType_OTHER_get, Swig_var_DeliveryScheduleSettlFlowType_OTHER_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlHolidaysProcessingInstruction_DO_NOT_INCLUDE_HOLIDAYS", Swig_var_DeliveryScheduleSettlHolidaysProcessingInstruction_DO_NOT_INCLUDE_HOLIDAYS_get, Swig_var_DeliveryScheduleSettlHolidaysProcessingInstruction_DO_NOT_INCLUDE_HOLIDAYS_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlHolidaysProcessingInstruction_INCLUDE_HOLIDAYS", Swig_var_DeliveryScheduleSettlHolidaysProcessingInstruction_INCLUDE_HOLIDAYS_get, Swig_var_DeliveryScheduleSettlHolidaysProcessingInstruction_INCLUDE_HOLIDAYS_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlDay_MONDAY", Swig_var_DeliveryScheduleSettlDay_MONDAY_get, Swig_var_DeliveryScheduleSettlDay_MONDAY_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlDay_TUESDAY", Swig_var_DeliveryScheduleSettlDay_TUESDAY_get, Swig_var_DeliveryScheduleSettlDay_TUESDAY_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlDay_WEDNESDAY", Swig_var_DeliveryScheduleSettlDay_WEDNESDAY_get, Swig_var_DeliveryScheduleSettlDay_WEDNESDAY_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlDay_THURSDAY", Swig_var_DeliveryScheduleSettlDay_THURSDAY_get, Swig_var_DeliveryScheduleSettlDay_THURSDAY_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlDay_FRIDAY", Swig_var_DeliveryScheduleSettlDay_FRIDAY_get, Swig_var_DeliveryScheduleSettlDay_FRIDAY_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlDay_SATURDAY", Swig_var_DeliveryScheduleSettlDay_SATURDAY_get, Swig_var_DeliveryScheduleSettlDay_SATURDAY_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlDay_SUNDAY", Swig_var_DeliveryScheduleSettlDay_SUNDAY_get, Swig_var_DeliveryScheduleSettlDay_SUNDAY_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlDay_ALL_WEEKDAYS", Swig_var_DeliveryScheduleSettlDay_ALL_WEEKDAYS_get, Swig_var_DeliveryScheduleSettlDay_ALL_WEEKDAYS_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlDay_ALL_DAYS", Swig_var_DeliveryScheduleSettlDay_ALL_DAYS_get, Swig_var_DeliveryScheduleSettlDay_ALL_DAYS_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlDay_ALL_WEEKENDS", Swig_var_DeliveryScheduleSettlDay_ALL_WEEKENDS_get, Swig_var_DeliveryScheduleSettlDay_ALL_WEEKENDS_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlTimeType_HOUR", Swig_var_DeliveryScheduleSettlTimeType_HOUR_get, Swig_var_DeliveryScheduleSettlTimeType_HOUR_set);
  SWIG_addvarlink(globals, "DeliveryScheduleSettlTimeType_TIMESTAMP", Swig_var_DeliveryScheduleSettlTimeType_TIMESTAMP_get, Swig_var_DeliveryScheduleSettlTimeType_TIMESTAMP_set);
  SWIG_addvarlink(globals, "DeliveryStreamType_PERIODIC", Swig_var_DeliveryStreamType_PERIODIC_get, Swig_var_DeliveryStreamType_PERIODIC_set);
  SWIG_addvarlink(globals, "DeliveryStreamType_INITIAL", Swig_var_DeliveryStreamType_INITIAL_get, Swig_var_DeliveryStreamType_INITIAL_set);
  SWIG_addvarlink(globals, "DeliveryStreamType_SINGLE", Swig_var_DeliveryStreamType_SINGLE_get, Swig_var_DeliveryStreamType_SINGLE_set);
  SWIG_addvarlink(globals, "DeliveryStreamDeliveryRestriction_FIRM", Swig_var_DeliveryStreamDeliveryRestriction_FIRM_get, Swig_var_DeliveryStreamDeliveryRestriction_FIRM_set);
  SWIG_addvarlink(globals, "DeliveryStreamDeliveryRestriction_NON_FIRM", Swig_var_DeliveryStreamDeliveryRestriction_NON_FIRM_get, Swig_var_DeliveryStreamDeliveryRestriction_NON_FIRM_set);
  SWIG_addvarlink(globals, "DeliveryStreamDeliveryRestriction_FORCE_MAJEURE", Swig_var_DeliveryStreamDeliveryRestriction_FORCE_MAJEURE_get, Swig_var_DeliveryStreamDeliveryRestriction_FORCE_MAJEURE_set);
  SWIG_addvarlink(globals, "DeliveryStreamDeliveryRestriction_SYSTEM_FIRM", Swig_var_DeliveryStreamDeliveryRestriction_SYSTEM_FIRM_get, Swig_var_DeliveryStreamDeliveryRestriction_SYSTEM_FIRM_set);
  SWIG_addvarlink(globals, "DeliveryStreamDeliveryRestriction_UNIT_FIRM", Swig_var_DeliveryStreamDeliveryRestriction_UNIT_FIRM_get, Swig_var_DeliveryStreamDeliveryRestriction_UNIT_FIRM_set);
  SWIG_addvarlink(globals, "DeliveryStreamTitleTransferCondition_TRANSFERS", Swig_var_DeliveryStreamTitleTransferCondition_TRANSFERS_get, Swig_var_DeliveryStreamTitleTransferCondition_TRANSFERS_set);
  SWIG_addvarlink(globals, "DeliveryStreamTitleTransferCondition_DOES_NOT_TRANSFER", Swig_var_DeliveryStreamTitleTransferCondition_DOES_NOT_TRANSFER_get, Swig_var_DeliveryStreamTitleTransferCondition_DOES_NOT_TRANSFER_set);
  SWIG_addvarlink(globals, "DeliveryStreamToleranceOptionSide_BUYER", Swig_var_DeliveryStreamToleranceOptionSide_BUYER_get, Swig_var_DeliveryStreamToleranceOptionSide_BUYER_set);
  SWIG_addvarlink(globals, "DeliveryStreamToleranceOptionSide_SELLER", Swig_var_DeliveryStreamToleranceOptionSide_SELLER_get, Swig_var_DeliveryStreamToleranceOptionSide_SELLER_set);
  SWIG_addvarlink(globals, "DeliveryStreamElectingPartySide_BUYER", Swig_var_DeliveryStreamElectingPartySide_BUYER_get, Swig_var_DeliveryStreamElectingPartySide_BUYER_set);
  SWIG_addvarlink(globals, "DeliveryStreamElectingPartySide_SELLER", Swig_var_DeliveryStreamElectingPartySide_SELLER_get, Swig_var_DeliveryStreamElectingPartySide_SELLER_set);
  SWIG_addvarlink(globals, "SwapSubClass_AMORTIZING", Swig_var_SwapSubClass_AMORTIZING_get, Swig_var_SwapSubClass_AMORTIZING_set);
  SWIG_addvarlink(globals, "SwapSubClass_COMPOUNDING", Swig_var_SwapSubClass_COMPOUNDING_get, Swig_var_SwapSubClass_COMPOUNDING_set);
  SWIG_addvarlink(globals, "SwapSubClass_CONSTANT_NOTIONAL_SCHEDULE", Swig_var_SwapSubClass_CONSTANT_NOTIONAL_SCHEDULE_get, Swig_var_SwapSubClass_CONSTANT_NOTIONAL_SCHEDULE_set);
  SWIG_addvarlink(globals, "SwapSubClass_ACCRETING_NOTIONAL_SCHEDULE", Swig_var_SwapSubClass_ACCRETING_NOTIONAL_SCHEDULE_get, Swig_var_SwapSubClass_ACCRETING_NOTIONAL_SCHEDULE_set);
  SWIG_addvarlink(globals, "SwapSubClass_CUSTOM_NOTIONAL_SCHEDULE", Swig_var_SwapSubClass_CUSTOM_NOTIONAL_SCHEDULE_get, Swig_var_SwapSubClass_CUSTOM_NOTIONAL_SCHEDULE_set);
  SWIG_addvarlink(globals, "StrategyType_STRADDLE", Swig_var_StrategyType_STRADDLE_get, Swig_var_StrategyType_STRADDLE_set);
  SWIG_addvarlink(globals, "StrategyType_STRANGLE", Swig_var_StrategyType_STRANGLE_get, Swig_var_StrategyType_STRANGLE_set);
  SWIG_addvarlink(globals, "StrategyType_BUTTERFLY", Swig_var_StrategyType_BUTTERFLY_get, Swig_var_StrategyType_BUTTERFLY_set);
  SWIG_addvarlink(globals, "StrategyType_CONDOR", Swig_var_StrategyType_CONDOR_get, Swig_var_StrategyType_CONDOR_set);
  SWIG_addvarlink(globals, "StrategyType_CALLABLE_INVERSIBLE_SNOWBALL", Swig_var_StrategyType_CALLABLE_INVERSIBLE_SNOWBALL_get, Swig_var_StrategyType_CALLABLE_INVERSIBLE_SNOWBALL_set);
  SWIG_addvarlink(globals, "StrategyType_OTHER", Swig_var_StrategyType_OTHER_get, Swig_var_StrategyType_OTHER_set);
  SWIG_addvarlink(globals, "SettlDisruptionProvision_NEGOTIATION", Swig_var_SettlDisruptionProvision_NEGOTIATION_get, Swig_var_SettlDisruptionProvision_NEGOTIATION_set);
  SWIG_addvarlink(globals, "SettlDisruptionProvision_CANCELLATION", Swig_var_SettlDisruptionProvision_CANCELLATION_get, Swig_var_SettlDisruptionProvision_CANCELLATION_set);
  SWIG_addvarlink(globals, "MarketDisruptionProvision_NOT_APPLICABLE", Swig_var_MarketDisruptionProvision_NOT_APPLICABLE_get, Swig_var_MarketDisruptionProvision_NOT_APPLICABLE_set);
  SWIG_addvarlink(globals, "MarketDisruptionProvision_APPLICABLE", Swig_var_MarketDisruptionProvision_APPLICABLE_get, Swig_var_MarketDisruptionProvision_APPLICABLE_set);
  SWIG_addvarlink(globals, "MarketDisruptionProvision_AS_IN_MASTER_AGREEMENT", Swig_var_MarketDisruptionProvision_AS_IN_MASTER_AGREEMENT_get, Swig_var_MarketDisruptionProvision_AS_IN_MASTER_AGREEMENT_set);
  SWIG_addvarlink(globals, "MarketDisruptionProvision_AS_IN_CONFIRMATION", Swig_var_MarketDisruptionProvision_AS_IN_CONFIRMATION_get, Swig_var_MarketDisruptionProvision_AS_IN_CONFIRMATION_set);
  SWIG_addvarlink(globals, "MarketDisruptionFallbackProvision_MASTER_AGREEMENT", Swig_var_MarketDisruptionFallbackProvision_MASTER_AGREEMENT_get, Swig_var_MarketDisruptionFallbackProvision_MASTER_AGREEMENT_set);
  SWIG_addvarlink(globals, "MarketDisruptionFallbackProvision_CONFIRMATION", Swig_var_MarketDisruptionFallbackProvision_CONFIRMATION_get, Swig_var_MarketDisruptionFallbackProvision_CONFIRMATION_set);
  SWIG_addvarlink(globals, "MarketDisruptionFallbackUnderlierType_BASKET", Swig_var_MarketDisruptionFallbackUnderlierType_BASKET_get, Swig_var_MarketDisruptionFallbackUnderlierType_BASKET_set);
  SWIG_addvarlink(globals, "MarketDisruptionFallbackUnderlierType_BOND", Swig_var_MarketDisruptionFallbackUnderlierType_BOND_get, Swig_var_MarketDisruptionFallbackUnderlierType_BOND_set);
  SWIG_addvarlink(globals, "MarketDisruptionFallbackUnderlierType_CASH", Swig_var_MarketDisruptionFallbackUnderlierType_CASH_get, Swig_var_MarketDisruptionFallbackUnderlierType_CASH_set);
  SWIG_addvarlink(globals, "MarketDisruptionFallbackUnderlierType_COMMODITY", Swig_var_MarketDisruptionFallbackUnderlierType_COMMODITY_get, Swig_var_MarketDisruptionFallbackUnderlierType_COMMODITY_set);
  SWIG_addvarlink(globals, "MarketDisruptionFallbackUnderlierType_CONVERTIBLE_BOND", Swig_var_MarketDisruptionFallbackUnderlierType_CONVERTIBLE_BOND_get, Swig_var_MarketDisruptionFallbackUnderlierType_CONVERTIBLE_BOND_set);
  SWIG_addvarlink(globals, "MarketDisruptionFallbackUnderlierType_EQUITY", Swig_var_MarketDisruptionFallbackUnderlierType_EQUITY_get, Swig_var_MarketDisruptionFallbackUnderlierType_EQUITY_set);
  SWIG_addvarlink(globals, "MarketDisruptionFallbackUnderlierType_EXCHANGE_TRADED_FUND", Swig_var_MarketDisruptionFallbackUnderlierType_EXCHANGE_TRADED_FUND_get, Swig_var_MarketDisruptionFallbackUnderlierType_EXCHANGE_TRADED_FUND_set);
  SWIG_addvarlink(globals, "MarketDisruptionFallbackUnderlierType_FUTURE", Swig_var_MarketDisruptionFallbackUnderlierType_FUTURE_get, Swig_var_MarketDisruptionFallbackUnderlierType_FUTURE_set);
  SWIG_addvarlink(globals, "MarketDisruptionFallbackUnderlierType_INDEX", Swig_var_MarketDisruptionFallbackUnderlierType_INDEX_get, Swig_var_MarketDisruptionFallbackUnderlierType_INDEX_set);
  SWIG_addvarlink(globals, "MarketDisruptionFallbackUnderlierType_LOAN", Swig_var_MarketDisruptionFallbackUnderlierType_LOAN_get, Swig_var_MarketDisruptionFallbackUnderlierType_LOAN_set);
  SWIG_addvarlink(globals, "MarketDisruptionFallbackUnderlierType_MORTGAGE", Swig_var_MarketDisruptionFallbackUnderlierType_MORTGAGE_get, Swig_var_MarketDisruptionFallbackUnderlierType_MORTGAGE_set);
  SWIG_addvarlink(globals, "MarketDisruptionFallbackUnderlierType_MUTUAL_FUND", Swig_var_MarketDisruptionFallbackUnderlierType_MUTUAL_FUND_get, Swig_var_MarketDisruptionFallbackUnderlierType_MUTUAL_FUND_set);
  SWIG_addvarlink(globals, "ExerciseConfirmationMethod_NOT_REQUIRED", Swig_var_ExerciseConfirmationMethod_NOT_REQUIRED_get, Swig_var_ExerciseConfirmationMethod_NOT_REQUIRED_set);
  SWIG_addvarlink(globals, "ExerciseConfirmationMethod_NON_ELECTRONIC", Swig_var_ExerciseConfirmationMethod_NON_ELECTRONIC_get, Swig_var_ExerciseConfirmationMethod_NON_ELECTRONIC_set);
  SWIG_addvarlink(globals, "ExerciseConfirmationMethod_ELECTRONIC", Swig_var_ExerciseConfirmationMethod_ELECTRONIC_get, Swig_var_ExerciseConfirmationMethod_ELECTRONIC_set);
  SWIG_addvarlink(globals, "ExerciseConfirmationMethod_UNKNOWN", Swig_var_ExerciseConfirmationMethod_UNKNOWN_get, Swig_var_ExerciseConfirmationMethod_UNKNOWN_set);
  SWIG_addvarlink(globals, "OptionExerciseDateType_UNADJUSTED", Swig_var_OptionExerciseDateType_UNADJUSTED_get, Swig_var_OptionExerciseDateType_UNADJUSTED_set);
  SWIG_addvarlink(globals, "OptionExerciseDateType_ADJUSTED", Swig_var_OptionExerciseDateType_ADJUSTED_get, Swig_var_OptionExerciseDateType_ADJUSTED_set);
  SWIG_addvarlink(globals, "PaymentDateOffsetDayType_BUSINESS", Swig_var_PaymentDateOffsetDayType_BUSINESS_get, Swig_var_PaymentDateOffsetDayType_BUSINESS_set);
  SWIG_addvarlink(globals, "PaymentDateOffsetDayType_CALENDAR", Swig_var_PaymentDateOffsetDayType_CALENDAR_get, Swig_var_PaymentDateOffsetDayType_CALENDAR_set);
  SWIG_addvarlink(globals, "PaymentDateOffsetDayType_COMMODITY", Swig_var_PaymentDateOffsetDayType_COMMODITY_get, Swig_var_PaymentDateOffsetDayType_COMMODITY_set);
  SWIG_addvarlink(globals, "PaymentDateOffsetDayType_CURRENCY", Swig_var_PaymentDateOffsetDayType_CURRENCY_get, Swig_var_PaymentDateOffsetDayType_CURRENCY_set);
  SWIG_addvarlink(globals, "PaymentDateOffsetDayType_EXCHANGE", Swig_var_PaymentDateOffsetDayType_EXCHANGE_get, Swig_var_PaymentDateOffsetDayType_EXCHANGE_set);
  SWIG_addvarlink(globals, "PaymentDateOffsetDayType_SCHEDULED", Swig_var_PaymentDateOffsetDayType_SCHEDULED_get, Swig_var_PaymentDateOffsetDayType_SCHEDULED_set);
  SWIG_addvarlink(globals, "PaymentForwardStartType_PREPAID", Swig_var_PaymentForwardStartType_PREPAID_get, Swig_var_PaymentForwardStartType_PREPAID_set);
  SWIG_addvarlink(globals, "PaymentForwardStartType_POSTPAID", Swig_var_PaymentForwardStartType_POSTPAID_get, Swig_var_PaymentForwardStartType_POSTPAID_set);
  SWIG_addvarlink(globals, "PaymentForwardStartType_VARIABLE", Swig_var_PaymentForwardStartType_VARIABLE_get, Swig_var_PaymentForwardStartType_VARIABLE_set);
  SWIG_addvarlink(globals, "PaymentForwardStartType_FIXED", Swig_var_PaymentForwardStartType_FIXED_get, Swig_var_PaymentForwardStartType_FIXED_set);
  SWIG_addvarlink(globals, "PaymentStreamSettlLevel_AVERAGE", Swig_var_PaymentStreamSettlLevel_AVERAGE_get, Swig_var_PaymentStreamSettlLevel_AVERAGE_set);
  SWIG_addvarlink(globals, "PaymentStreamSettlLevel_MAXIMUM", Swig_var_PaymentStreamSettlLevel_MAXIMUM_get, Swig_var_PaymentStreamSettlLevel_MAXIMUM_set);
  SWIG_addvarlink(globals, "PaymentStreamSettlLevel_MINIMUM", Swig_var_PaymentStreamSettlLevel_MINIMUM_get, Swig_var_PaymentStreamSettlLevel_MINIMUM_set);
  SWIG_addvarlink(globals, "PaymentStreamSettlLevel_CUMULATIVE", Swig_var_PaymentStreamSettlLevel_CUMULATIVE_get, Swig_var_PaymentStreamSettlLevel_CUMULATIVE_set);
  SWIG_addvarlink(globals, "PaymentStreamRateSpreadType_ABSOLUTE", Swig_var_PaymentStreamRateSpreadType_ABSOLUTE_get, Swig_var_PaymentStreamRateSpreadType_ABSOLUTE_set);
  SWIG_addvarlink(globals, "PaymentStreamRateSpreadType_PERCENTAGE", Swig_var_PaymentStreamRateSpreadType_PERCENTAGE_get, Swig_var_PaymentStreamRateSpreadType_PERCENTAGE_set);
  SWIG_addvarlink(globals, "PaymentStreamPricingDayDistribution_ALL", Swig_var_PaymentStreamPricingDayDistribution_ALL_get, Swig_var_PaymentStreamPricingDayDistribution_ALL_set);
  SWIG_addvarlink(globals, "PaymentStreamPricingDayDistribution_FIRST", Swig_var_PaymentStreamPricingDayDistribution_FIRST_get, Swig_var_PaymentStreamPricingDayDistribution_FIRST_set);
  SWIG_addvarlink(globals, "PaymentStreamPricingDayDistribution_LAST", Swig_var_PaymentStreamPricingDayDistribution_LAST_get, Swig_var_PaymentStreamPricingDayDistribution_LAST_set);
  SWIG_addvarlink(globals, "PaymentStreamPricingDayDistribution_PENULTIMATE", Swig_var_PaymentStreamPricingDayDistribution_PENULTIMATE_get, Swig_var_PaymentStreamPricingDayDistribution_PENULTIMATE_set);
  SWIG_addvarlink(globals, "PaymentStreamPricingDayOfWeek_EVERY_DAY", Swig_var_PaymentStreamPricingDayOfWeek_EVERY_DAY_get, Swig_var_PaymentStreamPricingDayOfWeek_EVERY_DAY_set);
  SWIG_addvarlink(globals, "PaymentStreamPricingDayOfWeek_MONDAY", Swig_var_PaymentStreamPricingDayOfWeek_MONDAY_get, Swig_var_PaymentStreamPricingDayOfWeek_MONDAY_set);
  SWIG_addvarlink(globals, "PaymentStreamPricingDayOfWeek_TUESDAY", Swig_var_PaymentStreamPricingDayOfWeek_TUESDAY_get, Swig_var_PaymentStreamPricingDayOfWeek_TUESDAY_set);
  SWIG_addvarlink(globals, "PaymentStreamPricingDayOfWeek_WEDNESDAY", Swig_var_PaymentStreamPricingDayOfWeek_WEDNESDAY_get, Swig_var_PaymentStreamPricingDayOfWeek_WEDNESDAY_set);
  SWIG_addvarlink(globals, "PaymentStreamPricingDayOfWeek_THURSDAY", Swig_var_PaymentStreamPricingDayOfWeek_THURSDAY_get, Swig_var_PaymentStreamPricingDayOfWeek_THURSDAY_set);
  SWIG_addvarlink(globals, "PaymentStreamPricingDayOfWeek_FRIDAY", Swig_var_PaymentStreamPricingDayOfWeek_FRIDAY_get, Swig_var_PaymentStreamPricingDayOfWeek_FRIDAY_set);
  SWIG_addvarlink(globals, "PaymentStreamPricingDayOfWeek_SATURDAY", Swig_var_PaymentStreamPricingDayOfWeek_SATURDAY_get, Swig_var_PaymentStreamPricingDayOfWeek_SATURDAY_set);
  SWIG_addvarlink(globals, "PaymentStreamPricingDayOfWeek_SUNDAY", Swig_var_PaymentStreamPricingDayOfWeek_SUNDAY_get, Swig_var_PaymentStreamPricingDayOfWeek_SUNDAY_set);
  SWIG_addvarlink(globals, "StreamCommodityNearbySettlDayUnit_WEEK", Swig_var_StreamCommodityNearbySettlDayUnit_WEEK_get, Swig_var_StreamCommodityNearbySettlDayUnit_WEEK_set);
  SWIG_addvarlink(globals, "StreamCommodityNearbySettlDayUnit_MONTH", Swig_var_StreamCommodityNearbySettlDayUnit_MONTH_get, Swig_var_StreamCommodityNearbySettlDayUnit_MONTH_set);
  SWIG_addvarlink(globals, "StreamCommoditySettlDateRollUnit_DAY", Swig_var_StreamCommoditySettlDateRollUnit_DAY_get, Swig_var_StreamCommoditySettlDateRollUnit_DAY_set);
  SWIG_addvarlink(globals, "StreamCommodityDataSourceIDType_CITY", Swig_var_StreamCommodityDataSourceIDType_CITY_get, Swig_var_StreamCommodityDataSourceIDType_CITY_set);
  SWIG_addvarlink(globals, "StreamCommodityDataSourceIDType_AIRPORT", Swig_var_StreamCommodityDataSourceIDType_AIRPORT_get, Swig_var_StreamCommodityDataSourceIDType_AIRPORT_set);
  SWIG_addvarlink(globals, "StreamCommodityDataSourceIDType_WEATHER_STATION", Swig_var_StreamCommodityDataSourceIDType_WEATHER_STATION_get, Swig_var_StreamCommodityDataSourceIDType_WEATHER_STATION_set);
  SWIG_addvarlink(globals, "StreamCommodityDataSourceIDType_WEATHER_INDEX", Swig_var_StreamCommodityDataSourceIDType_WEATHER_INDEX_get, Swig_var_StreamCommodityDataSourceIDType_WEATHER_INDEX_set);
  SWIG_addvarlink(globals, "StreamNotionalCommodityFrequency_TERM", Swig_var_StreamNotionalCommodityFrequency_TERM_get, Swig_var_StreamNotionalCommodityFrequency_TERM_set);
  SWIG_addvarlink(globals, "StreamNotionalCommodityFrequency_PER_BUSINESS_DAY", Swig_var_StreamNotionalCommodityFrequency_PER_BUSINESS_DAY_get, Swig_var_StreamNotionalCommodityFrequency_PER_BUSINESS_DAY_set);
  SWIG_addvarlink(globals, "StreamNotionalCommodityFrequency_PER_CALCULATION_PERIOD", Swig_var_StreamNotionalCommodityFrequency_PER_CALCULATION_PERIOD_get, Swig_var_StreamNotionalCommodityFrequency_PER_CALCULATION_PERIOD_set);
  SWIG_addvarlink(globals, "StreamNotionalCommodityFrequency_PER_SETTL_PERIOD", Swig_var_StreamNotionalCommodityFrequency_PER_SETTL_PERIOD_get, Swig_var_StreamNotionalCommodityFrequency_PER_SETTL_PERIOD_set);
  SWIG_addvarlink(globals, "StreamNotionalCommodityFrequency_PER_CALENDAR_DAY", Swig_var_StreamNotionalCommodityFrequency_PER_CALENDAR_DAY_get, Swig_var_StreamNotionalCommodityFrequency_PER_CALENDAR_DAY_set);
  SWIG_addvarlink(globals, "StreamNotionalCommodityFrequency_PER_HOUR", Swig_var_StreamNotionalCommodityFrequency_PER_HOUR_get, Swig_var_StreamNotionalCommodityFrequency_PER_HOUR_set);
  SWIG_addvarlink(globals, "StreamNotionalCommodityFrequency_PER_MONTH", Swig_var_StreamNotionalCommodityFrequency_PER_MONTH_get, Swig_var_StreamNotionalCommodityFrequency_PER_MONTH_set);
  SWIG_addvarlink(globals, "RiskLimitReportStatus_ACCEPTED", Swig_var_RiskLimitReportStatus_ACCEPTED_get, Swig_var_RiskLimitReportStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "RiskLimitReportStatus_REJECTED", Swig_var_RiskLimitReportStatus_REJECTED_get, Swig_var_RiskLimitReportStatus_REJECTED_set);
  SWIG_addvarlink(globals, "RiskLimitReportRejectReason_UNK_RISK_LMT_RPRT_ID", Swig_var_RiskLimitReportRejectReason_UNK_RISK_LMT_RPRT_ID_get, Swig_var_RiskLimitReportRejectReason_UNK_RISK_LMT_RPRT_ID_set);
  SWIG_addvarlink(globals, "RiskLimitReportRejectReason_UNK_PTY", Swig_var_RiskLimitReportRejectReason_UNK_PTY_get, Swig_var_RiskLimitReportRejectReason_UNK_PTY_set);
  SWIG_addvarlink(globals, "RiskLimitReportRejectReason_OTHER", Swig_var_RiskLimitReportRejectReason_OTHER_get, Swig_var_RiskLimitReportRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "RiskLimitCheckTransType_NEW", Swig_var_RiskLimitCheckTransType_NEW_get, Swig_var_RiskLimitCheckTransType_NEW_set);
  SWIG_addvarlink(globals, "RiskLimitCheckTransType_CANCEL", Swig_var_RiskLimitCheckTransType_CANCEL_get, Swig_var_RiskLimitCheckTransType_CANCEL_set);
  SWIG_addvarlink(globals, "RiskLimitCheckTransType_REPLACE", Swig_var_RiskLimitCheckTransType_REPLACE_get, Swig_var_RiskLimitCheckTransType_REPLACE_set);
  SWIG_addvarlink(globals, "RiskLimitCheckType_SUBMIT", Swig_var_RiskLimitCheckType_SUBMIT_get, Swig_var_RiskLimitCheckType_SUBMIT_set);
  SWIG_addvarlink(globals, "RiskLimitCheckType_LIMIT_CONSUMED", Swig_var_RiskLimitCheckType_LIMIT_CONSUMED_get, Swig_var_RiskLimitCheckType_LIMIT_CONSUMED_set);
  SWIG_addvarlink(globals, "RiskLimitCheckRequestType_ALL_OR_NONE", Swig_var_RiskLimitCheckRequestType_ALL_OR_NONE_get, Swig_var_RiskLimitCheckRequestType_ALL_OR_NONE_set);
  SWIG_addvarlink(globals, "RiskLimitCheckRequestType_PARTIAL", Swig_var_RiskLimitCheckRequestType_PARTIAL_get, Swig_var_RiskLimitCheckRequestType_PARTIAL_set);
  SWIG_addvarlink(globals, "RiskLimitCheckRequestStatus_APPROVED", Swig_var_RiskLimitCheckRequestStatus_APPROVED_get, Swig_var_RiskLimitCheckRequestStatus_APPROVED_set);
  SWIG_addvarlink(globals, "RiskLimitCheckRequestStatus_PARTIALLY_APPROVED", Swig_var_RiskLimitCheckRequestStatus_PARTIALLY_APPROVED_get, Swig_var_RiskLimitCheckRequestStatus_PARTIALLY_APPROVED_set);
  SWIG_addvarlink(globals, "RiskLimitCheckRequestStatus_REJECTED", Swig_var_RiskLimitCheckRequestStatus_REJECTED_get, Swig_var_RiskLimitCheckRequestStatus_REJECTED_set);
  SWIG_addvarlink(globals, "RiskLimitCheckRequestStatus_APPROVAL_PENDING", Swig_var_RiskLimitCheckRequestStatus_APPROVAL_PENDING_get, Swig_var_RiskLimitCheckRequestStatus_APPROVAL_PENDING_set);
  SWIG_addvarlink(globals, "RiskLimitCheckRequestStatus_CANCELLED", Swig_var_RiskLimitCheckRequestStatus_CANCELLED_get, Swig_var_RiskLimitCheckRequestStatus_CANCELLED_set);
  SWIG_addvarlink(globals, "RiskLimitCheckRequestResult_SUCCESSFUL", Swig_var_RiskLimitCheckRequestResult_SUCCESSFUL_get, Swig_var_RiskLimitCheckRequestResult_SUCCESSFUL_set);
  SWIG_addvarlink(globals, "RiskLimitCheckRequestResult_INVALID_PARTY", Swig_var_RiskLimitCheckRequestResult_INVALID_PARTY_get, Swig_var_RiskLimitCheckRequestResult_INVALID_PARTY_set);
  SWIG_addvarlink(globals, "RiskLimitCheckRequestResult_REQ_EXCEEDS_CREDIT_LIMIT", Swig_var_RiskLimitCheckRequestResult_REQ_EXCEEDS_CREDIT_LIMIT_get, Swig_var_RiskLimitCheckRequestResult_REQ_EXCEEDS_CREDIT_LIMIT_set);
  SWIG_addvarlink(globals, "RiskLimitCheckRequestResult_REQ_EXCEEDS_CLIP_SIZE_LIMIT", Swig_var_RiskLimitCheckRequestResult_REQ_EXCEEDS_CLIP_SIZE_LIMIT_get, Swig_var_RiskLimitCheckRequestResult_REQ_EXCEEDS_CLIP_SIZE_LIMIT_set);
  SWIG_addvarlink(globals, "RiskLimitCheckRequestResult_REQ_EXCEEDS_MAX_NOTIONAL", Swig_var_RiskLimitCheckRequestResult_REQ_EXCEEDS_MAX_NOTIONAL_get, Swig_var_RiskLimitCheckRequestResult_REQ_EXCEEDS_MAX_NOTIONAL_set);
  SWIG_addvarlink(globals, "RiskLimitCheckRequestResult_OTHER", Swig_var_RiskLimitCheckRequestResult_OTHER_get, Swig_var_RiskLimitCheckRequestResult_OTHER_set);
  SWIG_addvarlink(globals, "PartyActionType_SUSPEND", Swig_var_PartyActionType_SUSPEND_get, Swig_var_PartyActionType_SUSPEND_set);
  SWIG_addvarlink(globals, "PartyActionType_HALT_TRADING", Swig_var_PartyActionType_HALT_TRADING_get, Swig_var_PartyActionType_HALT_TRADING_set);
  SWIG_addvarlink(globals, "PartyActionType_REINSTATE", Swig_var_PartyActionType_REINSTATE_get, Swig_var_PartyActionType_REINSTATE_set);
  SWIG_addvarlink(globals, "PartyActionResponse_ACCEPTED", Swig_var_PartyActionResponse_ACCEPTED_get, Swig_var_PartyActionResponse_ACCEPTED_set);
  SWIG_addvarlink(globals, "PartyActionResponse_COMPLETED", Swig_var_PartyActionResponse_COMPLETED_get, Swig_var_PartyActionResponse_COMPLETED_set);
  SWIG_addvarlink(globals, "PartyActionResponse_REJECTED", Swig_var_PartyActionResponse_REJECTED_get, Swig_var_PartyActionResponse_REJECTED_set);
  SWIG_addvarlink(globals, "PartyActionRejectReason_INVALID_PARTY", Swig_var_PartyActionRejectReason_INVALID_PARTY_get, Swig_var_PartyActionRejectReason_INVALID_PARTY_set);
  SWIG_addvarlink(globals, "PartyActionRejectReason_UNK_REQ_PARTY", Swig_var_PartyActionRejectReason_UNK_REQ_PARTY_get, Swig_var_PartyActionRejectReason_UNK_REQ_PARTY_set);
  SWIG_addvarlink(globals, "PartyActionRejectReason_NOT_AUTHORIZED", Swig_var_PartyActionRejectReason_NOT_AUTHORIZED_get, Swig_var_PartyActionRejectReason_NOT_AUTHORIZED_set);
  SWIG_addvarlink(globals, "PartyActionRejectReason_OTHER", Swig_var_PartyActionRejectReason_OTHER_get, Swig_var_PartyActionRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "RefRiskLimitCheckIDType_RISK_LIMIT_REQUEST_ID", Swig_var_RefRiskLimitCheckIDType_RISK_LIMIT_REQUEST_ID_get, Swig_var_RefRiskLimitCheckIDType_RISK_LIMIT_REQUEST_ID_set);
  SWIG_addvarlink(globals, "RefRiskLimitCheckIDType_RISK_LIMIT_CHECK_ID", Swig_var_RefRiskLimitCheckIDType_RISK_LIMIT_CHECK_ID_get, Swig_var_RefRiskLimitCheckIDType_RISK_LIMIT_CHECK_ID_set);
  SWIG_addvarlink(globals, "RefRiskLimitCheckIDType_OUT_OF_BAND_ID", Swig_var_RefRiskLimitCheckIDType_OUT_OF_BAND_ID_get, Swig_var_RefRiskLimitCheckIDType_OUT_OF_BAND_ID_set);
  SWIG_addvarlink(globals, "RiskLimitCheckModelType_NONE", Swig_var_RiskLimitCheckModelType_NONE_get, Swig_var_RiskLimitCheckModelType_NONE_set);
  SWIG_addvarlink(globals, "RiskLimitCheckModelType_PLUS_ONE_MODEL", Swig_var_RiskLimitCheckModelType_PLUS_ONE_MODEL_get, Swig_var_RiskLimitCheckModelType_PLUS_ONE_MODEL_set);
  SWIG_addvarlink(globals, "RiskLimitCheckModelType_PING_MODEL", Swig_var_RiskLimitCheckModelType_PING_MODEL_get, Swig_var_RiskLimitCheckModelType_PING_MODEL_set);
  SWIG_addvarlink(globals, "RiskLimitCheckModelType_PUSH_MODEL", Swig_var_RiskLimitCheckModelType_PUSH_MODEL_get, Swig_var_RiskLimitCheckModelType_PUSH_MODEL_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_ACCEPTED", Swig_var_RiskLimitCheckStatus_ACCEPTED_get, Swig_var_RiskLimitCheckStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_REJECTED", Swig_var_RiskLimitCheckStatus_REJECTED_get, Swig_var_RiskLimitCheckStatus_REJECTED_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_CLAIM_REQUIRED", Swig_var_RiskLimitCheckStatus_CLAIM_REQUIRED_get, Swig_var_RiskLimitCheckStatus_CLAIM_REQUIRED_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_PRE_DEFINED_LIMIT_CHECK_SUCCEEDED", Swig_var_RiskLimitCheckStatus_PRE_DEFINED_LIMIT_CHECK_SUCCEEDED_get, Swig_var_RiskLimitCheckStatus_PRE_DEFINED_LIMIT_CHECK_SUCCEEDED_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_PRE_DEFINED_LIMIT_CHECK_FAILED", Swig_var_RiskLimitCheckStatus_PRE_DEFINED_LIMIT_CHECK_FAILED_get, Swig_var_RiskLimitCheckStatus_PRE_DEFINED_LIMIT_CHECK_FAILED_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_PRE_DEFINED_AUTO_ACCEPT_RULE_INVOKED", Swig_var_RiskLimitCheckStatus_PRE_DEFINED_AUTO_ACCEPT_RULE_INVOKED_get, Swig_var_RiskLimitCheckStatus_PRE_DEFINED_AUTO_ACCEPT_RULE_INVOKED_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_PRE_DEFINED_AUTO_REJECT_RULE_INVOKED", Swig_var_RiskLimitCheckStatus_PRE_DEFINED_AUTO_REJECT_RULE_INVOKED_get, Swig_var_RiskLimitCheckStatus_PRE_DEFINED_AUTO_REJECT_RULE_INVOKED_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_ACCEPTED_BY_CLEARING_FIRM", Swig_var_RiskLimitCheckStatus_ACCEPTED_BY_CLEARING_FIRM_get, Swig_var_RiskLimitCheckStatus_ACCEPTED_BY_CLEARING_FIRM_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_REJECTED_BY_CLEARING_FIRM", Swig_var_RiskLimitCheckStatus_REJECTED_BY_CLEARING_FIRM_get, Swig_var_RiskLimitCheckStatus_REJECTED_BY_CLEARING_FIRM_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_PENDING", Swig_var_RiskLimitCheckStatus_PENDING_get, Swig_var_RiskLimitCheckStatus_PENDING_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_ACCEPTED_BY_CREDIT_HUB", Swig_var_RiskLimitCheckStatus_ACCEPTED_BY_CREDIT_HUB_get, Swig_var_RiskLimitCheckStatus_ACCEPTED_BY_CREDIT_HUB_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_REJECTED_BY_CREDIT_HUB", Swig_var_RiskLimitCheckStatus_REJECTED_BY_CREDIT_HUB_get, Swig_var_RiskLimitCheckStatus_REJECTED_BY_CREDIT_HUB_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_PENDING_CREDIT_HUB_CHECK", Swig_var_RiskLimitCheckStatus_PENDING_CREDIT_HUB_CHECK_get, Swig_var_RiskLimitCheckStatus_PENDING_CREDIT_HUB_CHECK_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_ACCEPTED_BY_EXEC_VENUE", Swig_var_RiskLimitCheckStatus_ACCEPTED_BY_EXEC_VENUE_get, Swig_var_RiskLimitCheckStatus_ACCEPTED_BY_EXEC_VENUE_set);
  SWIG_addvarlink(globals, "RiskLimitCheckStatus_REJECTED_BY_EXEC_VENUE", Swig_var_RiskLimitCheckStatus_REJECTED_BY_EXEC_VENUE_get, Swig_var_RiskLimitCheckStatus_REJECTED_BY_EXEC_VENUE_set);
  SWIG_addvarlink(globals, "RegulatoryTransactionType_NONE", Swig_var_RegulatoryTransactionType_NONE_get, Swig_var_RegulatoryTransactionType_NONE_set);
  SWIG_addvarlink(globals, "RegulatoryTransactionType_SEF_REQUIRED_TRANSACTION", Swig_var_RegulatoryTransactionType_SEF_REQUIRED_TRANSACTION_get, Swig_var_RegulatoryTransactionType_SEF_REQUIRED_TRANSACTION_set);
  SWIG_addvarlink(globals, "RegulatoryTransactionType_SEF_PERMITTED_TRANSACTION", Swig_var_RegulatoryTransactionType_SEF_PERMITTED_TRANSACTION_get, Swig_var_RegulatoryTransactionType_SEF_PERMITTED_TRANSACTION_set);
  SWIG_addvarlink(globals, "BatchProcessMode_UPDATE", Swig_var_BatchProcessMode_UPDATE_get, Swig_var_BatchProcessMode_UPDATE_set);
  SWIG_addvarlink(globals, "BatchProcessMode_SNAPSHOT", Swig_var_BatchProcessMode_SNAPSHOT_get, Swig_var_BatchProcessMode_SNAPSHOT_set);
  SWIG_addvarlink(globals, "DeliveryStreamDeliveryPointSource_PROPRIETARY", Swig_var_DeliveryStreamDeliveryPointSource_PROPRIETARY_get, Swig_var_DeliveryStreamDeliveryPointSource_PROPRIETARY_set);
  SWIG_addvarlink(globals, "DeliveryStreamDeliveryPointSource_EIC", Swig_var_DeliveryStreamDeliveryPointSource_EIC_get, Swig_var_DeliveryStreamDeliveryPointSource_EIC_set);
  SWIG_addvarlink(globals, "TaxonomyType_ISIN_OR_ALT_INSTRMT_ID", Swig_var_TaxonomyType_ISIN_OR_ALT_INSTRMT_ID_get, Swig_var_TaxonomyType_ISIN_OR_ALT_INSTRMT_ID_set);
  SWIG_addvarlink(globals, "TaxonomyType_INTERIM_TAXONOMY", Swig_var_TaxonomyType_INTERIM_TAXONOMY_get, Swig_var_TaxonomyType_INTERIM_TAXONOMY_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDScope_CLEARING_MEMBER", Swig_var_RegulatoryTradeIDScope_CLEARING_MEMBER_get, Swig_var_RegulatoryTradeIDScope_CLEARING_MEMBER_set);
  SWIG_addvarlink(globals, "RegulatoryTradeIDScope_CLIENT", Swig_var_RegulatoryTradeIDScope_CLIENT_get, Swig_var_RegulatoryTradeIDScope_CLIENT_set);
  SWIG_addvarlink(globals, "EntitlementSubType_ORDER_ENTRY", Swig_var_EntitlementSubType_ORDER_ENTRY_get, Swig_var_EntitlementSubType_ORDER_ENTRY_set);
  SWIG_addvarlink(globals, "EntitlementSubType_H_IT_LIFT", Swig_var_EntitlementSubType_H_IT_LIFT_get, Swig_var_EntitlementSubType_H_IT_LIFT_set);
  SWIG_addvarlink(globals, "EntitlementSubType_VIEW_INDICATIVE_PX", Swig_var_EntitlementSubType_VIEW_INDICATIVE_PX_get, Swig_var_EntitlementSubType_VIEW_INDICATIVE_PX_set);
  SWIG_addvarlink(globals, "EntitlementSubType_VIEW_EXECUTABLE_PX", Swig_var_EntitlementSubType_VIEW_EXECUTABLE_PX_get, Swig_var_EntitlementSubType_VIEW_EXECUTABLE_PX_set);
  SWIG_addvarlink(globals, "EntitlementSubType_SINGLE_QUOTE", Swig_var_EntitlementSubType_SINGLE_QUOTE_get, Swig_var_EntitlementSubType_SINGLE_QUOTE_set);
  SWIG_addvarlink(globals, "EntitlementSubType_STREAMING_QUOTES", Swig_var_EntitlementSubType_STREAMING_QUOTES_get, Swig_var_EntitlementSubType_STREAMING_QUOTES_set);
  SWIG_addvarlink(globals, "EntitlementSubType_SINGLE_BROKER", Swig_var_EntitlementSubType_SINGLE_BROKER_get, Swig_var_EntitlementSubType_SINGLE_BROKER_set);
  SWIG_addvarlink(globals, "EntitlementSubType_MULTI_BROKERS", Swig_var_EntitlementSubType_MULTI_BROKERS_get, Swig_var_EntitlementSubType_MULTI_BROKERS_set);
  SWIG_addvarlink(globals, "QuoteModelType_QUOTE_ENTRY", Swig_var_QuoteModelType_QUOTE_ENTRY_get, Swig_var_QuoteModelType_QUOTE_ENTRY_set);
  SWIG_addvarlink(globals, "QuoteModelType_QUOTE_MODIFICATION", Swig_var_QuoteModelType_QUOTE_MODIFICATION_get, Swig_var_QuoteModelType_QUOTE_MODIFICATION_set);
  SWIG_addvarlink(globals, "ExecMethod_UNSPECIFIED", Swig_var_ExecMethod_UNSPECIFIED_get, Swig_var_ExecMethod_UNSPECIFIED_set);
  SWIG_addvarlink(globals, "ExecMethod_MANUAL", Swig_var_ExecMethod_MANUAL_get, Swig_var_ExecMethod_MANUAL_set);
  SWIG_addvarlink(globals, "ExecMethod_AUTOMATED", Swig_var_ExecMethod_AUTOMATED_get, Swig_var_ExecMethod_AUTOMATED_set);
  SWIG_addvarlink(globals, "ExecMethod_VOICE_BROKERED", Swig_var_ExecMethod_VOICE_BROKERED_get, Swig_var_ExecMethod_VOICE_BROKERED_set);
  SWIG_addvarlink(globals, "TradeContingency_DOES_NOT_APPLY", Swig_var_TradeContingency_DOES_NOT_APPLY_get, Swig_var_TradeContingency_DOES_NOT_APPLY_set);
  SWIG_addvarlink(globals, "TradeContingency_CONTINGENT_TRADE", Swig_var_TradeContingency_CONTINGENT_TRADE_get, Swig_var_TradeContingency_CONTINGENT_TRADE_set);
  SWIG_addvarlink(globals, "TradeContingency_NON_CONTINGENT_TRADE", Swig_var_TradeContingency_NON_CONTINGENT_TRADE_get, Swig_var_TradeContingency_NON_CONTINGENT_TRADE_set);
  SWIG_addvarlink(globals, "PaymentSubType_INITIAL", Swig_var_PaymentSubType_INITIAL_get, Swig_var_PaymentSubType_INITIAL_set);
  SWIG_addvarlink(globals, "PaymentSubType_INTERMEDIATE", Swig_var_PaymentSubType_INTERMEDIATE_get, Swig_var_PaymentSubType_INTERMEDIATE_set);
  SWIG_addvarlink(globals, "PaymentSubType_FINAL", Swig_var_PaymentSubType_FINAL_get, Swig_var_PaymentSubType_FINAL_set);
  SWIG_addvarlink(globals, "PaymentSubType_PREPAID", Swig_var_PaymentSubType_PREPAID_get, Swig_var_PaymentSubType_PREPAID_set);
  SWIG_addvarlink(globals, "PaymentSubType_POSTPAID", Swig_var_PaymentSubType_POSTPAID_get, Swig_var_PaymentSubType_POSTPAID_set);
  SWIG_addvarlink(globals, "PaymentSubType_VARIABLE", Swig_var_PaymentSubType_VARIABLE_get, Swig_var_PaymentSubType_VARIABLE_set);
  SWIG_addvarlink(globals, "PaymentSubType_FIXED", Swig_var_PaymentSubType_FIXED_get, Swig_var_PaymentSubType_FIXED_set);
  SWIG_addvarlink(globals, "PaymentSubType_SWAP", Swig_var_PaymentSubType_SWAP_get, Swig_var_PaymentSubType_SWAP_set);
  SWIG_addvarlink(globals, "PaymentSubType_CONDITIONAL", Swig_var_PaymentSubType_CONDITIONAL_get, Swig_var_PaymentSubType_CONDITIONAL_set);
  SWIG_addvarlink(globals, "PaymentSubType_FIXED_RATE", Swig_var_PaymentSubType_FIXED_RATE_get, Swig_var_PaymentSubType_FIXED_RATE_set);
  SWIG_addvarlink(globals, "PaymentSubType_FLOATING_RATE", Swig_var_PaymentSubType_FLOATING_RATE_get, Swig_var_PaymentSubType_FLOATING_RATE_set);
  SWIG_addvarlink(globals, "MassOrderRequestStatus_ACCEPTED", Swig_var_MassOrderRequestStatus_ACCEPTED_get, Swig_var_MassOrderRequestStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "MassOrderRequestStatus_ACCEPTED_WITH_ADDITIONAL_EVENTS", Swig_var_MassOrderRequestStatus_ACCEPTED_WITH_ADDITIONAL_EVENTS_get, Swig_var_MassOrderRequestStatus_ACCEPTED_WITH_ADDITIONAL_EVENTS_set);
  SWIG_addvarlink(globals, "MassOrderRequestStatus_REJECTED", Swig_var_MassOrderRequestStatus_REJECTED_get, Swig_var_MassOrderRequestStatus_REJECTED_set);
  SWIG_addvarlink(globals, "MassOrderRequestResult_SUCCESSFUL", Swig_var_MassOrderRequestResult_SUCCESSFUL_get, Swig_var_MassOrderRequestResult_SUCCESSFUL_set);
  SWIG_addvarlink(globals, "MassOrderRequestResult_RESPONSE_LEVEL_NOT_SUPPORTED", Swig_var_MassOrderRequestResult_RESPONSE_LEVEL_NOT_SUPPORTED_get, Swig_var_MassOrderRequestResult_RESPONSE_LEVEL_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "MassOrderRequestResult_INVALID_MARKET", Swig_var_MassOrderRequestResult_INVALID_MARKET_get, Swig_var_MassOrderRequestResult_INVALID_MARKET_set);
  SWIG_addvarlink(globals, "MassOrderRequestResult_INVALID_MARKET_SEGMENT", Swig_var_MassOrderRequestResult_INVALID_MARKET_SEGMENT_get, Swig_var_MassOrderRequestResult_INVALID_MARKET_SEGMENT_set);
  SWIG_addvarlink(globals, "MassOrderRequestResult_OTHER", Swig_var_MassOrderRequestResult_OTHER_get, Swig_var_MassOrderRequestResult_OTHER_set);
  SWIG_addvarlink(globals, "OrderResponseLevel_NO_ACK", Swig_var_OrderResponseLevel_NO_ACK_get, Swig_var_OrderResponseLevel_NO_ACK_set);
  SWIG_addvarlink(globals, "OrderResponseLevel_MINIMUM_ACK", Swig_var_OrderResponseLevel_MINIMUM_ACK_get, Swig_var_OrderResponseLevel_MINIMUM_ACK_set);
  SWIG_addvarlink(globals, "OrderResponseLevel_ACK_EACH", Swig_var_OrderResponseLevel_ACK_EACH_get, Swig_var_OrderResponseLevel_ACK_EACH_set);
  SWIG_addvarlink(globals, "OrderResponseLevel_SUMMARY_ACK", Swig_var_OrderResponseLevel_SUMMARY_ACK_get, Swig_var_OrderResponseLevel_SUMMARY_ACK_set);
  SWIG_addvarlink(globals, "OrderEntryAction_ADD", Swig_var_OrderEntryAction_ADD_get, Swig_var_OrderEntryAction_ADD_set);
  SWIG_addvarlink(globals, "OrderEntryAction_MODIFY", Swig_var_OrderEntryAction_MODIFY_get, Swig_var_OrderEntryAction_MODIFY_set);
  SWIG_addvarlink(globals, "OrderEntryAction_DELETE", Swig_var_OrderEntryAction_DELETE_get, Swig_var_OrderEntryAction_DELETE_set);
  SWIG_addvarlink(globals, "OrderEntryAction_SUSPEND", Swig_var_OrderEntryAction_SUSPEND_get, Swig_var_OrderEntryAction_SUSPEND_set);
  SWIG_addvarlink(globals, "OrderEntryAction_RELEASE", Swig_var_OrderEntryAction_RELEASE_get, Swig_var_OrderEntryAction_RELEASE_set);
  SWIG_addvarlink(globals, "ExecTypeReason_ORD_ADDED_ON_REQUEST", Swig_var_ExecTypeReason_ORD_ADDED_ON_REQUEST_get, Swig_var_ExecTypeReason_ORD_ADDED_ON_REQUEST_set);
  SWIG_addvarlink(globals, "ExecTypeReason_ORD_REPLACED_ON_REQUEST", Swig_var_ExecTypeReason_ORD_REPLACED_ON_REQUEST_get, Swig_var_ExecTypeReason_ORD_REPLACED_ON_REQUEST_set);
  SWIG_addvarlink(globals, "ExecTypeReason_ORD_CXLD_ON_REQUEST", Swig_var_ExecTypeReason_ORD_CXLD_ON_REQUEST_get, Swig_var_ExecTypeReason_ORD_CXLD_ON_REQUEST_set);
  SWIG_addvarlink(globals, "ExecTypeReason_UNSOLICITED_ORD_CXL", Swig_var_ExecTypeReason_UNSOLICITED_ORD_CXL_get, Swig_var_ExecTypeReason_UNSOLICITED_ORD_CXL_set);
  SWIG_addvarlink(globals, "ExecTypeReason_NON_RESTING_ORD_ADDED_ON_REQUEST", Swig_var_ExecTypeReason_NON_RESTING_ORD_ADDED_ON_REQUEST_get, Swig_var_ExecTypeReason_NON_RESTING_ORD_ADDED_ON_REQUEST_set);
  SWIG_addvarlink(globals, "ExecTypeReason_ORD_REPLACED_WITH_NON_RESTING_ORD_ON_REQUEST", Swig_var_ExecTypeReason_ORD_REPLACED_WITH_NON_RESTING_ORD_ON_REQUEST_get, Swig_var_ExecTypeReason_ORD_REPLACED_WITH_NON_RESTING_ORD_ON_REQUEST_set);
  SWIG_addvarlink(globals, "ExecTypeReason_TRIGGER_ORD_REPLACED_ON_REQUEST", Swig_var_ExecTypeReason_TRIGGER_ORD_REPLACED_ON_REQUEST_get, Swig_var_ExecTypeReason_TRIGGER_ORD_REPLACED_ON_REQUEST_set);
  SWIG_addvarlink(globals, "ExecTypeReason_SUSPENDED_ORD_REPLACED_ON_REQUEST", Swig_var_ExecTypeReason_SUSPENDED_ORD_REPLACED_ON_REQUEST_get, Swig_var_ExecTypeReason_SUSPENDED_ORD_REPLACED_ON_REQUEST_set);
  SWIG_addvarlink(globals, "ExecTypeReason_SUSPENDED_ORD_CXLD_ON_REQUEST", Swig_var_ExecTypeReason_SUSPENDED_ORD_CXLD_ON_REQUEST_get, Swig_var_ExecTypeReason_SUSPENDED_ORD_CXLD_ON_REQUEST_set);
  SWIG_addvarlink(globals, "ExecTypeReason_ORD_CXL_PENDING", Swig_var_ExecTypeReason_ORD_CXL_PENDING_get, Swig_var_ExecTypeReason_ORD_CXL_PENDING_set);
  SWIG_addvarlink(globals, "ExecTypeReason_PENDING_CXL_EXECUTED", Swig_var_ExecTypeReason_PENDING_CXL_EXECUTED_get, Swig_var_ExecTypeReason_PENDING_CXL_EXECUTED_set);
  SWIG_addvarlink(globals, "ExecTypeReason_RESTING_ORD_TRIGGERED", Swig_var_ExecTypeReason_RESTING_ORD_TRIGGERED_get, Swig_var_ExecTypeReason_RESTING_ORD_TRIGGERED_set);
  SWIG_addvarlink(globals, "ExecTypeReason_SUSPENDED_ORD_ACTIVATED", Swig_var_ExecTypeReason_SUSPENDED_ORD_ACTIVATED_get, Swig_var_ExecTypeReason_SUSPENDED_ORD_ACTIVATED_set);
  SWIG_addvarlink(globals, "ExecTypeReason_ACTIVE_ORD_SUSPENDED", Swig_var_ExecTypeReason_ACTIVE_ORD_SUSPENDED_get, Swig_var_ExecTypeReason_ACTIVE_ORD_SUSPENDED_set);
  SWIG_addvarlink(globals, "ExecTypeReason_ORD_EXPIRED", Swig_var_ExecTypeReason_ORD_EXPIRED_get, Swig_var_ExecTypeReason_ORD_EXPIRED_set);
  SWIG_addvarlink(globals, "TransferTransType_NEW", Swig_var_TransferTransType_NEW_get, Swig_var_TransferTransType_NEW_set);
  SWIG_addvarlink(globals, "TransferTransType_REPLACE", Swig_var_TransferTransType_REPLACE_get, Swig_var_TransferTransType_REPLACE_set);
  SWIG_addvarlink(globals, "TransferTransType_CANCEL", Swig_var_TransferTransType_CANCEL_get, Swig_var_TransferTransType_CANCEL_set);
  SWIG_addvarlink(globals, "TransferType_REQUEST_TRANSFER", Swig_var_TransferType_REQUEST_TRANSFER_get, Swig_var_TransferType_REQUEST_TRANSFER_set);
  SWIG_addvarlink(globals, "TransferType_ACCEPT_TRANSFER", Swig_var_TransferType_ACCEPT_TRANSFER_get, Swig_var_TransferType_ACCEPT_TRANSFER_set);
  SWIG_addvarlink(globals, "TransferType_DECLINE_TRANSFER", Swig_var_TransferType_DECLINE_TRANSFER_get, Swig_var_TransferType_DECLINE_TRANSFER_set);
  SWIG_addvarlink(globals, "TransferScope_INTER_FIRM_TRANSFER", Swig_var_TransferScope_INTER_FIRM_TRANSFER_get, Swig_var_TransferScope_INTER_FIRM_TRANSFER_set);
  SWIG_addvarlink(globals, "TransferScope_INTRA_FIRM_TRANSFER", Swig_var_TransferScope_INTRA_FIRM_TRANSFER_get, Swig_var_TransferScope_INTRA_FIRM_TRANSFER_set);
  SWIG_addvarlink(globals, "TransferScope_CMTA", Swig_var_TransferScope_CMTA_get, Swig_var_TransferScope_CMTA_set);
  SWIG_addvarlink(globals, "TransferStatus_RECEIVED", Swig_var_TransferStatus_RECEIVED_get, Swig_var_TransferStatus_RECEIVED_set);
  SWIG_addvarlink(globals, "TransferStatus_REJECTED_BY_INTERMEDIARY", Swig_var_TransferStatus_REJECTED_BY_INTERMEDIARY_get, Swig_var_TransferStatus_REJECTED_BY_INTERMEDIARY_set);
  SWIG_addvarlink(globals, "TransferStatus_ACCEPT_PENDING", Swig_var_TransferStatus_ACCEPT_PENDING_get, Swig_var_TransferStatus_ACCEPT_PENDING_set);
  SWIG_addvarlink(globals, "TransferStatus_ACCEPTED", Swig_var_TransferStatus_ACCEPTED_get, Swig_var_TransferStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "TransferStatus_DECLINED", Swig_var_TransferStatus_DECLINED_get, Swig_var_TransferStatus_DECLINED_set);
  SWIG_addvarlink(globals, "TransferStatus_CANCELLED", Swig_var_TransferStatus_CANCELLED_get, Swig_var_TransferStatus_CANCELLED_set);
  SWIG_addvarlink(globals, "TransferRejectReason_SUCCESS", Swig_var_TransferRejectReason_SUCCESS_get, Swig_var_TransferRejectReason_SUCCESS_set);
  SWIG_addvarlink(globals, "TransferRejectReason_INVALID_PARTY", Swig_var_TransferRejectReason_INVALID_PARTY_get, Swig_var_TransferRejectReason_INVALID_PARTY_set);
  SWIG_addvarlink(globals, "TransferRejectReason_UNKNOWN_INSTRUMENT", Swig_var_TransferRejectReason_UNKNOWN_INSTRUMENT_get, Swig_var_TransferRejectReason_UNKNOWN_INSTRUMENT_set);
  SWIG_addvarlink(globals, "TransferRejectReason_UNAUTHORIZED_TO_SUBMIT_XFER", Swig_var_TransferRejectReason_UNAUTHORIZED_TO_SUBMIT_XFER_get, Swig_var_TransferRejectReason_UNAUTHORIZED_TO_SUBMIT_XFER_set);
  SWIG_addvarlink(globals, "TransferRejectReason_UNKNOWN_POSITION", Swig_var_TransferRejectReason_UNKNOWN_POSITION_get, Swig_var_TransferRejectReason_UNKNOWN_POSITION_set);
  SWIG_addvarlink(globals, "TransferRejectReason_OTHER", Swig_var_TransferRejectReason_OTHER_get, Swig_var_TransferRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "TransferReportType_SUBMIT", Swig_var_TransferReportType_SUBMIT_get, Swig_var_TransferReportType_SUBMIT_set);
  SWIG_addvarlink(globals, "TransferReportType_ALLEGED", Swig_var_TransferReportType_ALLEGED_get, Swig_var_TransferReportType_ALLEGED_set);
  SWIG_addvarlink(globals, "MDStatisticType_COUNT", Swig_var_MDStatisticType_COUNT_get, Swig_var_MDStatisticType_COUNT_set);
  SWIG_addvarlink(globals, "MDStatisticType_AVERAGE_VOLUME", Swig_var_MDStatisticType_AVERAGE_VOLUME_get, Swig_var_MDStatisticType_AVERAGE_VOLUME_set);
  SWIG_addvarlink(globals, "MDStatisticType_TOTAL_VOLUME", Swig_var_MDStatisticType_TOTAL_VOLUME_get, Swig_var_MDStatisticType_TOTAL_VOLUME_set);
  SWIG_addvarlink(globals, "MDStatisticType_DISTRIBUTION", Swig_var_MDStatisticType_DISTRIBUTION_get, Swig_var_MDStatisticType_DISTRIBUTION_set);
  SWIG_addvarlink(globals, "MDStatisticType_RATIO", Swig_var_MDStatisticType_RATIO_get, Swig_var_MDStatisticType_RATIO_set);
  SWIG_addvarlink(globals, "MDStatisticType_LIQUIDITY", Swig_var_MDStatisticType_LIQUIDITY_get, Swig_var_MDStatisticType_LIQUIDITY_set);
  SWIG_addvarlink(globals, "MDStatisticType_VWAP", Swig_var_MDStatisticType_VWAP_get, Swig_var_MDStatisticType_VWAP_set);
  SWIG_addvarlink(globals, "MDStatisticType_VOLATILITY", Swig_var_MDStatisticType_VOLATILITY_get, Swig_var_MDStatisticType_VOLATILITY_set);
  SWIG_addvarlink(globals, "MDStatisticType_DURATION", Swig_var_MDStatisticType_DURATION_get, Swig_var_MDStatisticType_DURATION_set);
  SWIG_addvarlink(globals, "MDStatisticType_TICK", Swig_var_MDStatisticType_TICK_get, Swig_var_MDStatisticType_TICK_set);
  SWIG_addvarlink(globals, "MDStatisticType_AVERAGE_VALUE", Swig_var_MDStatisticType_AVERAGE_VALUE_get, Swig_var_MDStatisticType_AVERAGE_VALUE_set);
  SWIG_addvarlink(globals, "MDStatisticType_TOTAL_VALUE", Swig_var_MDStatisticType_TOTAL_VALUE_get, Swig_var_MDStatisticType_TOTAL_VALUE_set);
  SWIG_addvarlink(globals, "MDStatisticType_HIGH", Swig_var_MDStatisticType_HIGH_get, Swig_var_MDStatisticType_HIGH_set);
  SWIG_addvarlink(globals, "MDStatisticType_LOW", Swig_var_MDStatisticType_LOW_get, Swig_var_MDStatisticType_LOW_set);
  SWIG_addvarlink(globals, "MDStatisticType_MIDPOINT", Swig_var_MDStatisticType_MIDPOINT_get, Swig_var_MDStatisticType_MIDPOINT_set);
  SWIG_addvarlink(globals, "MDStatisticType_FIRST", Swig_var_MDStatisticType_FIRST_get, Swig_var_MDStatisticType_FIRST_set);
  SWIG_addvarlink(globals, "MDStatisticType_LAST", Swig_var_MDStatisticType_LAST_get, Swig_var_MDStatisticType_LAST_set);
  SWIG_addvarlink(globals, "MDStatisticType_FINAL", Swig_var_MDStatisticType_FINAL_get, Swig_var_MDStatisticType_FINAL_set);
  SWIG_addvarlink(globals, "MDStatisticType_EXCHANGE_BEST", Swig_var_MDStatisticType_EXCHANGE_BEST_get, Swig_var_MDStatisticType_EXCHANGE_BEST_set);
  SWIG_addvarlink(globals, "MDStatisticType_EXCHANGE_BEST_WITH_VOLUME", Swig_var_MDStatisticType_EXCHANGE_BEST_WITH_VOLUME_get, Swig_var_MDStatisticType_EXCHANGE_BEST_WITH_VOLUME_set);
  SWIG_addvarlink(globals, "MDStatisticType_CONSOLIDATED_BEST", Swig_var_MDStatisticType_CONSOLIDATED_BEST_get, Swig_var_MDStatisticType_CONSOLIDATED_BEST_set);
  SWIG_addvarlink(globals, "MDStatisticType_CONSOLIDATED_BEST_WITH_VOLUME", Swig_var_MDStatisticType_CONSOLIDATED_BEST_WITH_VOLUME_get, Swig_var_MDStatisticType_CONSOLIDATED_BEST_WITH_VOLUME_set);
  SWIG_addvarlink(globals, "MDStatisticType_TWAP", Swig_var_MDStatisticType_TWAP_get, Swig_var_MDStatisticType_TWAP_set);
  SWIG_addvarlink(globals, "MDStatisticType_AVERAGE_DURATION", Swig_var_MDStatisticType_AVERAGE_DURATION_get, Swig_var_MDStatisticType_AVERAGE_DURATION_set);
  SWIG_addvarlink(globals, "MDStatisticType_AVERAGE_PRICE", Swig_var_MDStatisticType_AVERAGE_PRICE_get, Swig_var_MDStatisticType_AVERAGE_PRICE_set);
  SWIG_addvarlink(globals, "MDStatisticType_TOTAL_FEES", Swig_var_MDStatisticType_TOTAL_FEES_get, Swig_var_MDStatisticType_TOTAL_FEES_set);
  SWIG_addvarlink(globals, "MDStatisticType_TOTAL_BENEFITS", Swig_var_MDStatisticType_TOTAL_BENEFITS_get, Swig_var_MDStatisticType_TOTAL_BENEFITS_set);
  SWIG_addvarlink(globals, "MDStatisticType_MEDIAN_VALUE", Swig_var_MDStatisticType_MEDIAN_VALUE_get, Swig_var_MDStatisticType_MEDIAN_VALUE_set);
  SWIG_addvarlink(globals, "MDStatisticType_AVERAGE_LIQUIDITY", Swig_var_MDStatisticType_AVERAGE_LIQUIDITY_get, Swig_var_MDStatisticType_AVERAGE_LIQUIDITY_set);
  SWIG_addvarlink(globals, "MDStatisticType_MEDIAN_DURATION", Swig_var_MDStatisticType_MEDIAN_DURATION_get, Swig_var_MDStatisticType_MEDIAN_DURATION_set);
  SWIG_addvarlink(globals, "MDStatisticScope_BID_PRICES", Swig_var_MDStatisticScope_BID_PRICES_get, Swig_var_MDStatisticScope_BID_PRICES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_OFFER_PRICES", Swig_var_MDStatisticScope_OFFER_PRICES_get, Swig_var_MDStatisticScope_OFFER_PRICES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_BID_DEPTH", Swig_var_MDStatisticScope_BID_DEPTH_get, Swig_var_MDStatisticScope_BID_DEPTH_set);
  SWIG_addvarlink(globals, "MDStatisticScope_OFFER_DEPTH", Swig_var_MDStatisticScope_OFFER_DEPTH_get, Swig_var_MDStatisticScope_OFFER_DEPTH_set);
  SWIG_addvarlink(globals, "MDStatisticScope_ORDERS", Swig_var_MDStatisticScope_ORDERS_get, Swig_var_MDStatisticScope_ORDERS_set);
  SWIG_addvarlink(globals, "MDStatisticScope_QUOTES", Swig_var_MDStatisticScope_QUOTES_get, Swig_var_MDStatisticScope_QUOTES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_ORDERS_AND_QUOTES", Swig_var_MDStatisticScope_ORDERS_AND_QUOTES_get, Swig_var_MDStatisticScope_ORDERS_AND_QUOTES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_TRADES", Swig_var_MDStatisticScope_TRADES_get, Swig_var_MDStatisticScope_TRADES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_TRADE_PRICES", Swig_var_MDStatisticScope_TRADE_PRICES_get, Swig_var_MDStatisticScope_TRADE_PRICES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_AUCTION_PRICES", Swig_var_MDStatisticScope_AUCTION_PRICES_get, Swig_var_MDStatisticScope_AUCTION_PRICES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_OPENING_PRICES", Swig_var_MDStatisticScope_OPENING_PRICES_get, Swig_var_MDStatisticScope_OPENING_PRICES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_CLOSING_PRICES", Swig_var_MDStatisticScope_CLOSING_PRICES_get, Swig_var_MDStatisticScope_CLOSING_PRICES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_SETTLEMENT_PRICES", Swig_var_MDStatisticScope_SETTLEMENT_PRICES_get, Swig_var_MDStatisticScope_SETTLEMENT_PRICES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_UNDERLYING_PRICES", Swig_var_MDStatisticScope_UNDERLYING_PRICES_get, Swig_var_MDStatisticScope_UNDERLYING_PRICES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_OPEN_INTEREST", Swig_var_MDStatisticScope_OPEN_INTEREST_get, Swig_var_MDStatisticScope_OPEN_INTEREST_set);
  SWIG_addvarlink(globals, "MDStatisticScope_INDEX_VALUES", Swig_var_MDStatisticScope_INDEX_VALUES_get, Swig_var_MDStatisticScope_INDEX_VALUES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_MARGIN_RATES", Swig_var_MDStatisticScope_MARGIN_RATES_get, Swig_var_MDStatisticScope_MARGIN_RATES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_OUTAGES", Swig_var_MDStatisticScope_OUTAGES_get, Swig_var_MDStatisticScope_OUTAGES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_SCHEDULED_AUCTIONS", Swig_var_MDStatisticScope_SCHEDULED_AUCTIONS_get, Swig_var_MDStatisticScope_SCHEDULED_AUCTIONS_set);
  SWIG_addvarlink(globals, "MDStatisticScope_REFERENCE_PRICES", Swig_var_MDStatisticScope_REFERENCE_PRICES_get, Swig_var_MDStatisticScope_REFERENCE_PRICES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_TRADE_VALUE", Swig_var_MDStatisticScope_TRADE_VALUE_get, Swig_var_MDStatisticScope_TRADE_VALUE_set);
  SWIG_addvarlink(globals, "MDStatisticScope_MARKET_DATA_FEE_ITEMS", Swig_var_MDStatisticScope_MARKET_DATA_FEE_ITEMS_get, Swig_var_MDStatisticScope_MARKET_DATA_FEE_ITEMS_set);
  SWIG_addvarlink(globals, "MDStatisticScope_REBATES", Swig_var_MDStatisticScope_REBATES_get, Swig_var_MDStatisticScope_REBATES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_DISCOUNTS", Swig_var_MDStatisticScope_DISCOUNTS_get, Swig_var_MDStatisticScope_DISCOUNTS_set);
  SWIG_addvarlink(globals, "MDStatisticScope_PAYMENTS", Swig_var_MDStatisticScope_PAYMENTS_get, Swig_var_MDStatisticScope_PAYMENTS_set);
  SWIG_addvarlink(globals, "MDStatisticScope_TAXES", Swig_var_MDStatisticScope_TAXES_get, Swig_var_MDStatisticScope_TAXES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_LEVIES", Swig_var_MDStatisticScope_LEVIES_get, Swig_var_MDStatisticScope_LEVIES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_BENEFITS", Swig_var_MDStatisticScope_BENEFITS_get, Swig_var_MDStatisticScope_BENEFITS_set);
  SWIG_addvarlink(globals, "MDStatisticScope_FEES", Swig_var_MDStatisticScope_FEES_get, Swig_var_MDStatisticScope_FEES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_ORDERS_RF_QS", Swig_var_MDStatisticScope_ORDERS_RF_QS_get, Swig_var_MDStatisticScope_ORDERS_RF_QS_set);
  SWIG_addvarlink(globals, "MDStatisticScope_MARKET_MAKERS", Swig_var_MDStatisticScope_MARKET_MAKERS_get, Swig_var_MDStatisticScope_MARKET_MAKERS_set);
  SWIG_addvarlink(globals, "MDStatisticScope_TRADING_INTERRUPTIONS", Swig_var_MDStatisticScope_TRADING_INTERRUPTIONS_get, Swig_var_MDStatisticScope_TRADING_INTERRUPTIONS_set);
  SWIG_addvarlink(globals, "MDStatisticScope_TRADING_SUSPENSIONS", Swig_var_MDStatisticScope_TRADING_SUSPENSIONS_get, Swig_var_MDStatisticScope_TRADING_SUSPENSIONS_set);
  SWIG_addvarlink(globals, "MDStatisticScope_NO_QUOTES", Swig_var_MDStatisticScope_NO_QUOTES_get, Swig_var_MDStatisticScope_NO_QUOTES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_REQUEST_FOR_QUOTES", Swig_var_MDStatisticScope_REQUEST_FOR_QUOTES_get, Swig_var_MDStatisticScope_REQUEST_FOR_QUOTES_set);
  SWIG_addvarlink(globals, "MDStatisticScope_TRADE_VOLUME", Swig_var_MDStatisticScope_TRADE_VOLUME_get, Swig_var_MDStatisticScope_TRADE_VOLUME_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_VISIBLE", Swig_var_MDStatisticSubScope_VISIBLE_get, Swig_var_MDStatisticSubScope_VISIBLE_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_HIDDEN", Swig_var_MDStatisticSubScope_HIDDEN_get, Swig_var_MDStatisticSubScope_HIDDEN_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_INDICATIVE", Swig_var_MDStatisticSubScope_INDICATIVE_get, Swig_var_MDStatisticSubScope_INDICATIVE_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_TRADEABLE", Swig_var_MDStatisticSubScope_TRADEABLE_get, Swig_var_MDStatisticSubScope_TRADEABLE_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_PASSIVE", Swig_var_MDStatisticSubScope_PASSIVE_get, Swig_var_MDStatisticSubScope_PASSIVE_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_MARKET_CONSENSUS", Swig_var_MDStatisticSubScope_MARKET_CONSENSUS_get, Swig_var_MDStatisticSubScope_MARKET_CONSENSUS_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_POWER", Swig_var_MDStatisticSubScope_POWER_get, Swig_var_MDStatisticSubScope_POWER_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_HARDWARE_ERROR", Swig_var_MDStatisticSubScope_HARDWARE_ERROR_get, Swig_var_MDStatisticSubScope_HARDWARE_ERROR_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_SOFTWARE_ERROR", Swig_var_MDStatisticSubScope_SOFTWARE_ERROR_get, Swig_var_MDStatisticSubScope_SOFTWARE_ERROR_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_NETWORK_ERROR", Swig_var_MDStatisticSubScope_NETWORK_ERROR_get, Swig_var_MDStatisticSubScope_NETWORK_ERROR_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_FAILED", Swig_var_MDStatisticSubScope_FAILED_get, Swig_var_MDStatisticSubScope_FAILED_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_EXECUTED", Swig_var_MDStatisticSubScope_EXECUTED_get, Swig_var_MDStatisticSubScope_EXECUTED_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_ENTERED", Swig_var_MDStatisticSubScope_ENTERED_get, Swig_var_MDStatisticSubScope_ENTERED_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_MODIFIED", Swig_var_MDStatisticSubScope_MODIFIED_get, Swig_var_MDStatisticSubScope_MODIFIED_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_CANCELLED", Swig_var_MDStatisticSubScope_CANCELLED_get, Swig_var_MDStatisticSubScope_CANCELLED_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_MARKET_DATA_ACCESS", Swig_var_MDStatisticSubScope_MARKET_DATA_ACCESS_get, Swig_var_MDStatisticSubScope_MARKET_DATA_ACCESS_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_TERMINAL_ACCESS", Swig_var_MDStatisticSubScope_TERMINAL_ACCESS_get, Swig_var_MDStatisticSubScope_TERMINAL_ACCESS_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_VOLUME", Swig_var_MDStatisticSubScope_VOLUME_get, Swig_var_MDStatisticSubScope_VOLUME_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_CLEARED", Swig_var_MDStatisticSubScope_CLEARED_get, Swig_var_MDStatisticSubScope_CLEARED_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_SETTLED", Swig_var_MDStatisticSubScope_SETTLED_get, Swig_var_MDStatisticSubScope_SETTLED_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_OTHER", Swig_var_MDStatisticSubScope_OTHER_get, Swig_var_MDStatisticSubScope_OTHER_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_MONETARY", Swig_var_MDStatisticSubScope_MONETARY_get, Swig_var_MDStatisticSubScope_MONETARY_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_NON_MONETARY", Swig_var_MDStatisticSubScope_NON_MONETARY_get, Swig_var_MDStatisticSubScope_NON_MONETARY_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_GROSS", Swig_var_MDStatisticSubScope_GROSS_get, Swig_var_MDStatisticSubScope_GROSS_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_LARGE_IN_SCALE", Swig_var_MDStatisticSubScope_LARGE_IN_SCALE_get, Swig_var_MDStatisticSubScope_LARGE_IN_SCALE_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_NEITHER_HIDDEN_NOR_LARGE_IN_SCALE", Swig_var_MDStatisticSubScope_NEITHER_HIDDEN_NOR_LARGE_IN_SCALE_get, Swig_var_MDStatisticSubScope_NEITHER_HIDDEN_NOR_LARGE_IN_SCALE_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_CORPORATE_ACTION", Swig_var_MDStatisticSubScope_CORPORATE_ACTION_get, Swig_var_MDStatisticSubScope_CORPORATE_ACTION_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_VENUE_DECISION", Swig_var_MDStatisticSubScope_VENUE_DECISION_get, Swig_var_MDStatisticSubScope_VENUE_DECISION_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_MINIMUM_TIME_PERIOD", Swig_var_MDStatisticSubScope_MINIMUM_TIME_PERIOD_get, Swig_var_MDStatisticSubScope_MINIMUM_TIME_PERIOD_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_OPEN", Swig_var_MDStatisticSubScope_OPEN_get, Swig_var_MDStatisticSubScope_OPEN_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_NOT_EXECUTED", Swig_var_MDStatisticSubScope_NOT_EXECUTED_get, Swig_var_MDStatisticSubScope_NOT_EXECUTED_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_AGGRESSIVE", Swig_var_MDStatisticSubScope_AGGRESSIVE_get, Swig_var_MDStatisticSubScope_AGGRESSIVE_set);
  SWIG_addvarlink(globals, "MDStatisticSubScope_DIRECTED", Swig_var_MDStatisticSubScope_DIRECTED_get, Swig_var_MDStatisticSubScope_DIRECTED_set);
  SWIG_addvarlink(globals, "MDStatisticScopeType_ENTRY_RATE", Swig_var_MDStatisticScopeType_ENTRY_RATE_get, Swig_var_MDStatisticScopeType_ENTRY_RATE_set);
  SWIG_addvarlink(globals, "MDStatisticScopeType_MODIFICATION_RATE", Swig_var_MDStatisticScopeType_MODIFICATION_RATE_get, Swig_var_MDStatisticScopeType_MODIFICATION_RATE_set);
  SWIG_addvarlink(globals, "MDStatisticScopeType_CANCEL_RATE", Swig_var_MDStatisticScopeType_CANCEL_RATE_get, Swig_var_MDStatisticScopeType_CANCEL_RATE_set);
  SWIG_addvarlink(globals, "MDStatisticScopeType_DOWNWARD_MOVE", Swig_var_MDStatisticScopeType_DOWNWARD_MOVE_get, Swig_var_MDStatisticScopeType_DOWNWARD_MOVE_set);
  SWIG_addvarlink(globals, "MDStatisticScopeType_UPWARD_MOVE", Swig_var_MDStatisticScopeType_UPWARD_MOVE_get, Swig_var_MDStatisticScopeType_UPWARD_MOVE_set);
  SWIG_addvarlink(globals, "MDStatisticIntervalType_SLIDING_WINDOW", Swig_var_MDStatisticIntervalType_SLIDING_WINDOW_get, Swig_var_MDStatisticIntervalType_SLIDING_WINDOW_set);
  SWIG_addvarlink(globals, "MDStatisticIntervalType_SLIDING_WINDOW_PEAK", Swig_var_MDStatisticIntervalType_SLIDING_WINDOW_PEAK_get, Swig_var_MDStatisticIntervalType_SLIDING_WINDOW_PEAK_set);
  SWIG_addvarlink(globals, "MDStatisticIntervalType_FIXED_DATE_RANGE", Swig_var_MDStatisticIntervalType_FIXED_DATE_RANGE_get, Swig_var_MDStatisticIntervalType_FIXED_DATE_RANGE_set);
  SWIG_addvarlink(globals, "MDStatisticIntervalType_FIXED_TIME_RANGE", Swig_var_MDStatisticIntervalType_FIXED_TIME_RANGE_get, Swig_var_MDStatisticIntervalType_FIXED_TIME_RANGE_set);
  SWIG_addvarlink(globals, "MDStatisticIntervalType_CURRENT_TIME_UNIT", Swig_var_MDStatisticIntervalType_CURRENT_TIME_UNIT_get, Swig_var_MDStatisticIntervalType_CURRENT_TIME_UNIT_set);
  SWIG_addvarlink(globals, "MDStatisticIntervalType_PREVIOUS_TIME_UNIT", Swig_var_MDStatisticIntervalType_PREVIOUS_TIME_UNIT_get, Swig_var_MDStatisticIntervalType_PREVIOUS_TIME_UNIT_set);
  SWIG_addvarlink(globals, "MDStatisticIntervalType_MAXIMUM_RANGE", Swig_var_MDStatisticIntervalType_MAXIMUM_RANGE_get, Swig_var_MDStatisticIntervalType_MAXIMUM_RANGE_set);
  SWIG_addvarlink(globals, "MDStatisticIntervalType_MAXIMUM_RANGE_UP_TO_PREVIOUS_TIME_UNIT", Swig_var_MDStatisticIntervalType_MAXIMUM_RANGE_UP_TO_PREVIOUS_TIME_UNIT_get, Swig_var_MDStatisticIntervalType_MAXIMUM_RANGE_UP_TO_PREVIOUS_TIME_UNIT_set);
  SWIG_addvarlink(globals, "MDStatisticRatioType_BUYERS_TO_SELLERS", Swig_var_MDStatisticRatioType_BUYERS_TO_SELLERS_get, Swig_var_MDStatisticRatioType_BUYERS_TO_SELLERS_set);
  SWIG_addvarlink(globals, "MDStatisticRatioType_UPTICKS_TO_DOWNTICKS", Swig_var_MDStatisticRatioType_UPTICKS_TO_DOWNTICKS_get, Swig_var_MDStatisticRatioType_UPTICKS_TO_DOWNTICKS_set);
  SWIG_addvarlink(globals, "MDStatisticRatioType_MARKET_MAKER_TO_NON_MARKET_MAKER", Swig_var_MDStatisticRatioType_MARKET_MAKER_TO_NON_MARKET_MAKER_get, Swig_var_MDStatisticRatioType_MARKET_MAKER_TO_NON_MARKET_MAKER_set);
  SWIG_addvarlink(globals, "MDStatisticRatioType_AUTOMATED_TO_NON_AUTOMATED", Swig_var_MDStatisticRatioType_AUTOMATED_TO_NON_AUTOMATED_get, Swig_var_MDStatisticRatioType_AUTOMATED_TO_NON_AUTOMATED_set);
  SWIG_addvarlink(globals, "MDStatisticRatioType_ORDERS_TO_TRADES", Swig_var_MDStatisticRatioType_ORDERS_TO_TRADES_get, Swig_var_MDStatisticRatioType_ORDERS_TO_TRADES_set);
  SWIG_addvarlink(globals, "MDStatisticRatioType_QUOTES_TO_TRADES", Swig_var_MDStatisticRatioType_QUOTES_TO_TRADES_get, Swig_var_MDStatisticRatioType_QUOTES_TO_TRADES_set);
  SWIG_addvarlink(globals, "MDStatisticRatioType_ORDERS_AND_QUOTES_TO_TRADES", Swig_var_MDStatisticRatioType_ORDERS_AND_QUOTES_TO_TRADES_get, Swig_var_MDStatisticRatioType_ORDERS_AND_QUOTES_TO_TRADES_set);
  SWIG_addvarlink(globals, "MDStatisticRatioType_FAILED_TO_TOTAL_TRADED_VALUE", Swig_var_MDStatisticRatioType_FAILED_TO_TOTAL_TRADED_VALUE_get, Swig_var_MDStatisticRatioType_FAILED_TO_TOTAL_TRADED_VALUE_set);
  SWIG_addvarlink(globals, "MDStatisticRatioType_BENEFITS_TO_TOTAL_TRADED_VALUE", Swig_var_MDStatisticRatioType_BENEFITS_TO_TOTAL_TRADED_VALUE_get, Swig_var_MDStatisticRatioType_BENEFITS_TO_TOTAL_TRADED_VALUE_set);
  SWIG_addvarlink(globals, "MDStatisticRatioType_FEES_TO_TOTAL_TRADED_VALUE", Swig_var_MDStatisticRatioType_FEES_TO_TOTAL_TRADED_VALUE_get, Swig_var_MDStatisticRatioType_FEES_TO_TOTAL_TRADED_VALUE_set);
  SWIG_addvarlink(globals, "MDStatisticRatioType_TRADE_VOLUME_TO_TOTAL_TRADED_VOLUME", Swig_var_MDStatisticRatioType_TRADE_VOLUME_TO_TOTAL_TRADED_VOLUME_get, Swig_var_MDStatisticRatioType_TRADE_VOLUME_TO_TOTAL_TRADED_VOLUME_set);
  SWIG_addvarlink(globals, "MDStatisticRatioType_ORDERS_TO_TOTAL_NUMBER_ORDERS", Swig_var_MDStatisticRatioType_ORDERS_TO_TOTAL_NUMBER_ORDERS_get, Swig_var_MDStatisticRatioType_ORDERS_TO_TOTAL_NUMBER_ORDERS_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_SUCCESSFUL", Swig_var_MDStatisticRequestResult_SUCCESSFUL_get, Swig_var_MDStatisticRequestResult_SUCCESSFUL_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_INVALID_OR_UNKNOWN_MARKET", Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_MARKET_get, Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_MARKET_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_INVALID_OR_UNKNOWN_MARKET_SEGMENT", Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_MARKET_SEGMENT_get, Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_MARKET_SEGMENT_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_INVALID_OR_UNKNOWN_SECURITY_LIST", Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_SECURITY_LIST_get, Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_SECURITY_LIST_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_INVALID_OR_UNKNOWN_INSTRUMENTS", Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_INSTRUMENTS_get, Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_INSTRUMENTS_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_INVALID_PARTIES", Swig_var_MDStatisticRequestResult_INVALID_PARTIES_get, Swig_var_MDStatisticRequestResult_INVALID_PARTIES_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_TRADE_DATE_OUT_OF_SUPPORTED_RANGE", Swig_var_MDStatisticRequestResult_TRADE_DATE_OUT_OF_SUPPORTED_RANGE_get, Swig_var_MDStatisticRequestResult_TRADE_DATE_OUT_OF_SUPPORTED_RANGE_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_UNSUPPORTED_STATISTIC_TYPE", Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_TYPE_get, Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_TYPE_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_UNSUPPORTED_SCOPE_OR_SUB_SCOPE", Swig_var_MDStatisticRequestResult_UNSUPPORTED_SCOPE_OR_SUB_SCOPE_get, Swig_var_MDStatisticRequestResult_UNSUPPORTED_SCOPE_OR_SUB_SCOPE_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_UNSUPPORTED_SCOPE_TYPE", Swig_var_MDStatisticRequestResult_UNSUPPORTED_SCOPE_TYPE_get, Swig_var_MDStatisticRequestResult_UNSUPPORTED_SCOPE_TYPE_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_MARKET_DEPTH_NOT_SUPPORTED", Swig_var_MDStatisticRequestResult_MARKET_DEPTH_NOT_SUPPORTED_get, Swig_var_MDStatisticRequestResult_MARKET_DEPTH_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_FREQUENCY_NOT_SUPPORTED", Swig_var_MDStatisticRequestResult_FREQUENCY_NOT_SUPPORTED_get, Swig_var_MDStatisticRequestResult_FREQUENCY_NOT_SUPPORTED_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_UNSUPPORTED_STATISTIC_INTERVAL", Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_INTERVAL_get, Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_INTERVAL_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_UNSUPPORTED_STATISTIC_DATE_RANGE", Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_DATE_RANGE_get, Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_DATE_RANGE_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_UNSUPPORTED_STATISTIC_TIME_RANGE", Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_TIME_RANGE_get, Swig_var_MDStatisticRequestResult_UNSUPPORTED_STATISTIC_TIME_RANGE_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_UNSUPPORTED_RATIO_TYPE", Swig_var_MDStatisticRequestResult_UNSUPPORTED_RATIO_TYPE_get, Swig_var_MDStatisticRequestResult_UNSUPPORTED_RATIO_TYPE_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_INVALID_OR_UNKNOWN_TRADE_INPUT_SOURCE", Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_TRADE_INPUT_SOURCE_get, Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_TRADE_INPUT_SOURCE_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_INVALID_OR_UNKNOWN_TRADING_SESSION", Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_TRADING_SESSION_get, Swig_var_MDStatisticRequestResult_INVALID_OR_UNKNOWN_TRADING_SESSION_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_UNAUTHORIZED_FOR_STATISTIC_REQUEST", Swig_var_MDStatisticRequestResult_UNAUTHORIZED_FOR_STATISTIC_REQUEST_get, Swig_var_MDStatisticRequestResult_UNAUTHORIZED_FOR_STATISTIC_REQUEST_set);
  SWIG_addvarlink(globals, "MDStatisticRequestResult_OTHER", Swig_var_MDStatisticRequestResult_OTHER_get, Swig_var_MDStatisticRequestResult_OTHER_set);
  SWIG_addvarlink(globals, "MDStatisticStatus_ACTIVE", Swig_var_MDStatisticStatus_ACTIVE_get, Swig_var_MDStatisticStatus_ACTIVE_set);
  SWIG_addvarlink(globals, "MDStatisticStatus_INACTIVE", Swig_var_MDStatisticStatus_INACTIVE_get, Swig_var_MDStatisticStatus_INACTIVE_set);
  SWIG_addvarlink(globals, "MDStatisticValueType_ABSOLUTE", Swig_var_MDStatisticValueType_ABSOLUTE_get, Swig_var_MDStatisticValueType_ABSOLUTE_set);
  SWIG_addvarlink(globals, "MDStatisticValueType_PERCENTAGE", Swig_var_MDStatisticValueType_PERCENTAGE_get, Swig_var_MDStatisticValueType_PERCENTAGE_set);
  SWIG_addvarlink(globals, "AssetGroup_FINANCIALS", Swig_var_AssetGroup_FINANCIALS_get, Swig_var_AssetGroup_FINANCIALS_set);
  SWIG_addvarlink(globals, "AssetGroup_COMMODITIES", Swig_var_AssetGroup_COMMODITIES_get, Swig_var_AssetGroup_COMMODITIES_set);
  SWIG_addvarlink(globals, "AssetGroup_ALTERNATIVE_INVESTMENTS", Swig_var_AssetGroup_ALTERNATIVE_INVESTMENTS_get, Swig_var_AssetGroup_ALTERNATIVE_INVESTMENTS_set);
  SWIG_addvarlink(globals, "CollRptRejectReason_UNKNOWN_TRADE", Swig_var_CollRptRejectReason_UNKNOWN_TRADE_get, Swig_var_CollRptRejectReason_UNKNOWN_TRADE_set);
  SWIG_addvarlink(globals, "CollRptRejectReason_UNKNOWN_INSTRUMENT", Swig_var_CollRptRejectReason_UNKNOWN_INSTRUMENT_get, Swig_var_CollRptRejectReason_UNKNOWN_INSTRUMENT_set);
  SWIG_addvarlink(globals, "CollRptRejectReason_UNKNOWN_COUNTERPARTY", Swig_var_CollRptRejectReason_UNKNOWN_COUNTERPARTY_get, Swig_var_CollRptRejectReason_UNKNOWN_COUNTERPARTY_set);
  SWIG_addvarlink(globals, "CollRptRejectReason_UNKNOWN_POSITION", Swig_var_CollRptRejectReason_UNKNOWN_POSITION_get, Swig_var_CollRptRejectReason_UNKNOWN_POSITION_set);
  SWIG_addvarlink(globals, "CollRptRejectReason_UNACCEPTABLE_COLLATERAL", Swig_var_CollRptRejectReason_UNACCEPTABLE_COLLATERAL_get, Swig_var_CollRptRejectReason_UNACCEPTABLE_COLLATERAL_set);
  SWIG_addvarlink(globals, "CollRptRejectReason_OTHER", Swig_var_CollRptRejectReason_OTHER_get, Swig_var_CollRptRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "CollRptStatus_ACCEPTED", Swig_var_CollRptStatus_ACCEPTED_get, Swig_var_CollRptStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "CollRptStatus_RECEIVED", Swig_var_CollRptStatus_RECEIVED_get, Swig_var_CollRptStatus_RECEIVED_set);
  SWIG_addvarlink(globals, "CollRptStatus_REJECTED", Swig_var_CollRptStatus_REJECTED_get, Swig_var_CollRptStatus_REJECTED_set);
  SWIG_addvarlink(globals, "RelativeValueType_ASW_SPREAD", Swig_var_RelativeValueType_ASW_SPREAD_get, Swig_var_RelativeValueType_ASW_SPREAD_set);
  SWIG_addvarlink(globals, "RelativeValueType_OIS", Swig_var_RelativeValueType_OIS_get, Swig_var_RelativeValueType_OIS_set);
  SWIG_addvarlink(globals, "RelativeValueType_Z_SPREAD", Swig_var_RelativeValueType_Z_SPREAD_get, Swig_var_RelativeValueType_Z_SPREAD_set);
  SWIG_addvarlink(globals, "RelativeValueType_DISCOUNT_MARGIN", Swig_var_RelativeValueType_DISCOUNT_MARGIN_get, Swig_var_RelativeValueType_DISCOUNT_MARGIN_set);
  SWIG_addvarlink(globals, "RelativeValueType_I_SPREAD", Swig_var_RelativeValueType_I_SPREAD_get, Swig_var_RelativeValueType_I_SPREAD_set);
  SWIG_addvarlink(globals, "RelativeValueType_OAS", Swig_var_RelativeValueType_OAS_get, Swig_var_RelativeValueType_OAS_set);
  SWIG_addvarlink(globals, "RelativeValueType_G_SPREAD", Swig_var_RelativeValueType_G_SPREAD_get, Swig_var_RelativeValueType_G_SPREAD_set);
  SWIG_addvarlink(globals, "RelativeValueType_CDS_BASIS", Swig_var_RelativeValueType_CDS_BASIS_get, Swig_var_RelativeValueType_CDS_BASIS_set);
  SWIG_addvarlink(globals, "RelativeValueType_CDS_INTERPOLATED_BASIS", Swig_var_RelativeValueType_CDS_INTERPOLATED_BASIS_get, Swig_var_RelativeValueType_CDS_INTERPOLATED_BASIS_set);
  SWIG_addvarlink(globals, "RelativeValueType_DV01", Swig_var_RelativeValueType_DV01_get, Swig_var_RelativeValueType_DV01_set);
  SWIG_addvarlink(globals, "RelativeValueType_PV01", Swig_var_RelativeValueType_PV01_get, Swig_var_RelativeValueType_PV01_set);
  SWIG_addvarlink(globals, "RelativeValueType_CS01", Swig_var_RelativeValueType_CS01_get, Swig_var_RelativeValueType_CS01_set);
  SWIG_addvarlink(globals, "RelativeValueSide_BID", Swig_var_RelativeValueSide_BID_get, Swig_var_RelativeValueSide_BID_set);
  SWIG_addvarlink(globals, "RelativeValueSide_MID", Swig_var_RelativeValueSide_MID_get, Swig_var_RelativeValueSide_MID_set);
  SWIG_addvarlink(globals, "RelativeValueSide_OFFER", Swig_var_RelativeValueSide_OFFER_get, Swig_var_RelativeValueSide_OFFER_set);
  SWIG_addvarlink(globals, "MDReportEvent_START_INSTRUMENT_REF_DATA", Swig_var_MDReportEvent_START_INSTRUMENT_REF_DATA_get, Swig_var_MDReportEvent_START_INSTRUMENT_REF_DATA_set);
  SWIG_addvarlink(globals, "MDReportEvent_END_INSTRUMENT_REF_DATA", Swig_var_MDReportEvent_END_INSTRUMENT_REF_DATA_get, Swig_var_MDReportEvent_END_INSTRUMENT_REF_DATA_set);
  SWIG_addvarlink(globals, "MDReportEvent_START_OFF_MARKET_TRADES", Swig_var_MDReportEvent_START_OFF_MARKET_TRADES_get, Swig_var_MDReportEvent_START_OFF_MARKET_TRADES_set);
  SWIG_addvarlink(globals, "MDReportEvent_END_OFF_MARKET_TRADES", Swig_var_MDReportEvent_END_OFF_MARKET_TRADES_get, Swig_var_MDReportEvent_END_OFF_MARKET_TRADES_set);
  SWIG_addvarlink(globals, "MDReportEvent_START_ORDER_BOOK_TRADES", Swig_var_MDReportEvent_START_ORDER_BOOK_TRADES_get, Swig_var_MDReportEvent_START_ORDER_BOOK_TRADES_set);
  SWIG_addvarlink(globals, "MDReportEvent_END_ORDER_BOOK_TRADES", Swig_var_MDReportEvent_END_ORDER_BOOK_TRADES_get, Swig_var_MDReportEvent_END_ORDER_BOOK_TRADES_set);
  SWIG_addvarlink(globals, "MDReportEvent_START_OPEN_INTEREST", Swig_var_MDReportEvent_START_OPEN_INTEREST_get, Swig_var_MDReportEvent_START_OPEN_INTEREST_set);
  SWIG_addvarlink(globals, "MDReportEvent_END_OPEN_INTEREST", Swig_var_MDReportEvent_END_OPEN_INTEREST_get, Swig_var_MDReportEvent_END_OPEN_INTEREST_set);
  SWIG_addvarlink(globals, "MDReportEvent_START_SETTLEMENT_PRICES", Swig_var_MDReportEvent_START_SETTLEMENT_PRICES_get, Swig_var_MDReportEvent_START_SETTLEMENT_PRICES_set);
  SWIG_addvarlink(globals, "MDReportEvent_END_SETTLEMENT_PRICES", Swig_var_MDReportEvent_END_SETTLEMENT_PRICES_get, Swig_var_MDReportEvent_END_SETTLEMENT_PRICES_set);
  SWIG_addvarlink(globals, "MDReportEvent_START_STATS_REF_DATA", Swig_var_MDReportEvent_START_STATS_REF_DATA_get, Swig_var_MDReportEvent_START_STATS_REF_DATA_set);
  SWIG_addvarlink(globals, "MDReportEvent_END_STATS_REF_DATA", Swig_var_MDReportEvent_END_STATS_REF_DATA_get, Swig_var_MDReportEvent_END_STATS_REF_DATA_set);
  SWIG_addvarlink(globals, "MDReportEvent_START_STATISTICS", Swig_var_MDReportEvent_START_STATISTICS_get, Swig_var_MDReportEvent_START_STATISTICS_set);
  SWIG_addvarlink(globals, "MDReportEvent_END_STATISTICS", Swig_var_MDReportEvent_END_STATISTICS_get, Swig_var_MDReportEvent_END_STATISTICS_set);
  SWIG_addvarlink(globals, "MarketSegmentStatus_ACTIVE", Swig_var_MarketSegmentStatus_ACTIVE_get, Swig_var_MarketSegmentStatus_ACTIVE_set);
  SWIG_addvarlink(globals, "MarketSegmentStatus_INACTIVE", Swig_var_MarketSegmentStatus_INACTIVE_get, Swig_var_MarketSegmentStatus_INACTIVE_set);
  SWIG_addvarlink(globals, "MarketSegmentStatus_PUBLISHED", Swig_var_MarketSegmentStatus_PUBLISHED_get, Swig_var_MarketSegmentStatus_PUBLISHED_set);
  SWIG_addvarlink(globals, "MarketSegmentType_POOL", Swig_var_MarketSegmentType_POOL_get, Swig_var_MarketSegmentType_POOL_set);
  SWIG_addvarlink(globals, "MarketSegmentType_RETAIL", Swig_var_MarketSegmentType_RETAIL_get, Swig_var_MarketSegmentType_RETAIL_set);
  SWIG_addvarlink(globals, "MarketSegmentType_WHOLESALE", Swig_var_MarketSegmentType_WHOLESALE_get, Swig_var_MarketSegmentType_WHOLESALE_set);
  SWIG_addvarlink(globals, "MarketSegmentSubType_INTER_PRODUCT_SPREAD", Swig_var_MarketSegmentSubType_INTER_PRODUCT_SPREAD_get, Swig_var_MarketSegmentSubType_INTER_PRODUCT_SPREAD_set);
  SWIG_addvarlink(globals, "MarketSegmentRelationship_MARKET_SEGMENT_POOL_MEMBER", Swig_var_MarketSegmentRelationship_MARKET_SEGMENT_POOL_MEMBER_get, Swig_var_MarketSegmentRelationship_MARKET_SEGMENT_POOL_MEMBER_set);
  SWIG_addvarlink(globals, "MarketSegmentRelationship_RETAIL_SEGMENT", Swig_var_MarketSegmentRelationship_RETAIL_SEGMENT_get, Swig_var_MarketSegmentRelationship_RETAIL_SEGMENT_set);
  SWIG_addvarlink(globals, "MarketSegmentRelationship_WHOLESALE_SEGMENT", Swig_var_MarketSegmentRelationship_WHOLESALE_SEGMENT_get, Swig_var_MarketSegmentRelationship_WHOLESALE_SEGMENT_set);
  SWIG_addvarlink(globals, "QuoteSideIndicator_NO", Swig_var_QuoteSideIndicator_NO_get, Swig_var_QuoteSideIndicator_NO_set);
  SWIG_addvarlink(globals, "QuoteSideIndicator_YES", Swig_var_QuoteSideIndicator_YES_get, Swig_var_QuoteSideIndicator_YES_set);
  SWIG_addvarlink(globals, "CustomerPriority_NO_PRIORITY", Swig_var_CustomerPriority_NO_PRIORITY_get, Swig_var_CustomerPriority_NO_PRIORITY_set);
  SWIG_addvarlink(globals, "CustomerPriority_UNCONDITIONAL_PRIORITY", Swig_var_CustomerPriority_UNCONDITIONAL_PRIORITY_get, Swig_var_CustomerPriority_UNCONDITIONAL_PRIORITY_set);
  SWIG_addvarlink(globals, "SettlSubMethod_SHARES", Swig_var_SettlSubMethod_SHARES_get, Swig_var_SettlSubMethod_SHARES_set);
  SWIG_addvarlink(globals, "SettlSubMethod_DERIVATIVES", Swig_var_SettlSubMethod_DERIVATIVES_get, Swig_var_SettlSubMethod_DERIVATIVES_set);
  SWIG_addvarlink(globals, "SettlSubMethod_PAYMENT_VS_PAYMENT", Swig_var_SettlSubMethod_PAYMENT_VS_PAYMENT_get, Swig_var_SettlSubMethod_PAYMENT_VS_PAYMENT_set);
  SWIG_addvarlink(globals, "SettlSubMethod_NOTIONAL", Swig_var_SettlSubMethod_NOTIONAL_get, Swig_var_SettlSubMethod_NOTIONAL_set);
  SWIG_addvarlink(globals, "SettlSubMethod_CASCADE", Swig_var_SettlSubMethod_CASCADE_get, Swig_var_SettlSubMethod_CASCADE_set);
  SWIG_addvarlink(globals, "SettlSubMethod_REPURCHASE", Swig_var_SettlSubMethod_REPURCHASE_get, Swig_var_SettlSubMethod_REPURCHASE_set);
  SWIG_addvarlink(globals, "SettlSubMethod_OTHER", Swig_var_SettlSubMethod_OTHER_get, Swig_var_SettlSubMethod_OTHER_set);
  SWIG_addvarlink(globals, "CalculationMethod_AUTOMATIC", Swig_var_CalculationMethod_AUTOMATIC_get, Swig_var_CalculationMethod_AUTOMATIC_set);
  SWIG_addvarlink(globals, "CalculationMethod_MANUAL", Swig_var_CalculationMethod_MANUAL_get, Swig_var_CalculationMethod_MANUAL_set);
  SWIG_addvarlink(globals, "CollateralAmountType_MARKET_VALUATION", Swig_var_CollateralAmountType_MARKET_VALUATION_get, Swig_var_CollateralAmountType_MARKET_VALUATION_set);
  SWIG_addvarlink(globals, "CollateralAmountType_PORTFOLIO_VALUE", Swig_var_CollateralAmountType_PORTFOLIO_VALUE_get, Swig_var_CollateralAmountType_PORTFOLIO_VALUE_set);
  SWIG_addvarlink(globals, "CollateralAmountType_VALUE_CONFIRMED", Swig_var_CollateralAmountType_VALUE_CONFIRMED_get, Swig_var_CollateralAmountType_VALUE_CONFIRMED_set);
  SWIG_addvarlink(globals, "CollateralAmountType_COLLATERAL_CREDIT_VALUE", Swig_var_CollateralAmountType_COLLATERAL_CREDIT_VALUE_get, Swig_var_CollateralAmountType_COLLATERAL_CREDIT_VALUE_set);
  SWIG_addvarlink(globals, "CollateralAmountType_ADDITIONAL_COLLATERAL_VALUE", Swig_var_CollateralAmountType_ADDITIONAL_COLLATERAL_VALUE_get, Swig_var_CollateralAmountType_ADDITIONAL_COLLATERAL_VALUE_set);
  SWIG_addvarlink(globals, "CollateralAmountType_ESTIMATED_MARKET_VALUATION", Swig_var_CollateralAmountType_ESTIMATED_MARKET_VALUATION_get, Swig_var_CollateralAmountType_ESTIMATED_MARKET_VALUATION_set);
  SWIG_addvarlink(globals, "CommissionAmountType_UNSPECIFIED", Swig_var_CommissionAmountType_UNSPECIFIED_get, Swig_var_CommissionAmountType_UNSPECIFIED_set);
  SWIG_addvarlink(globals, "CommissionAmountType_ACCEPTANCE", Swig_var_CommissionAmountType_ACCEPTANCE_get, Swig_var_CommissionAmountType_ACCEPTANCE_set);
  SWIG_addvarlink(globals, "CommissionAmountType_BROKER", Swig_var_CommissionAmountType_BROKER_get, Swig_var_CommissionAmountType_BROKER_set);
  SWIG_addvarlink(globals, "CommissionAmountType_CLEARING_BROKER", Swig_var_CommissionAmountType_CLEARING_BROKER_get, Swig_var_CommissionAmountType_CLEARING_BROKER_set);
  SWIG_addvarlink(globals, "CommissionAmountType_RETAIL", Swig_var_CommissionAmountType_RETAIL_get, Swig_var_CommissionAmountType_RETAIL_set);
  SWIG_addvarlink(globals, "CommissionAmountType_SALES_COMMISSION", Swig_var_CommissionAmountType_SALES_COMMISSION_get, Swig_var_CommissionAmountType_SALES_COMMISSION_set);
  SWIG_addvarlink(globals, "CommissionAmountType_LOCAL_COMMISSION", Swig_var_CommissionAmountType_LOCAL_COMMISSION_get, Swig_var_CommissionAmountType_LOCAL_COMMISSION_set);
  SWIG_addvarlink(globals, "CommissionAmountType_RESEARCH_PAYMENT", Swig_var_CommissionAmountType_RESEARCH_PAYMENT_get, Swig_var_CommissionAmountType_RESEARCH_PAYMENT_set);
  SWIG_addvarlink(globals, "CashSettlPriceDefault_CLOSE", Swig_var_CashSettlPriceDefault_CLOSE_get, Swig_var_CashSettlPriceDefault_CLOSE_set);
  SWIG_addvarlink(globals, "CashSettlPriceDefault_HEDGE", Swig_var_CashSettlPriceDefault_HEDGE_get, Swig_var_CashSettlPriceDefault_HEDGE_set);
  SWIG_addvarlink(globals, "ComplexEventPVFinalPriceElectionFallback_CLOSE", Swig_var_ComplexEventPVFinalPriceElectionFallback_CLOSE_get, Swig_var_ComplexEventPVFinalPriceElectionFallback_CLOSE_set);
  SWIG_addvarlink(globals, "ComplexEventPVFinalPriceElectionFallback_HEDGE_ELECTION", Swig_var_ComplexEventPVFinalPriceElectionFallback_HEDGE_ELECTION_get, Swig_var_ComplexEventPVFinalPriceElectionFallback_HEDGE_ELECTION_set);
  SWIG_addvarlink(globals, "DividendEntitlementEvent_EX_DATE", Swig_var_DividendEntitlementEvent_EX_DATE_get, Swig_var_DividendEntitlementEvent_EX_DATE_set);
  SWIG_addvarlink(globals, "DividendEntitlementEvent_RECORD_DATE", Swig_var_DividendEntitlementEvent_RECORD_DATE_get, Swig_var_DividendEntitlementEvent_RECORD_DATE_set);
  SWIG_addvarlink(globals, "DividendAmountType_RECORD_AMOUNT", Swig_var_DividendAmountType_RECORD_AMOUNT_get, Swig_var_DividendAmountType_RECORD_AMOUNT_set);
  SWIG_addvarlink(globals, "DividendAmountType_EX_AMOUNT", Swig_var_DividendAmountType_EX_AMOUNT_get, Swig_var_DividendAmountType_EX_AMOUNT_set);
  SWIG_addvarlink(globals, "DividendAmountType_PAID_AMOUNT", Swig_var_DividendAmountType_PAID_AMOUNT_get, Swig_var_DividendAmountType_PAID_AMOUNT_set);
  SWIG_addvarlink(globals, "DividendAmountType_PER_MASTER_CONFIRM", Swig_var_DividendAmountType_PER_MASTER_CONFIRM_get, Swig_var_DividendAmountType_PER_MASTER_CONFIRM_set);
  SWIG_addvarlink(globals, "NonCashDividendTreatment_POTENTIAL_ADJUSTMENT", Swig_var_NonCashDividendTreatment_POTENTIAL_ADJUSTMENT_get, Swig_var_NonCashDividendTreatment_POTENTIAL_ADJUSTMENT_set);
  SWIG_addvarlink(globals, "NonCashDividendTreatment_CASH_EQUIVALENT", Swig_var_NonCashDividendTreatment_CASH_EQUIVALENT_get, Swig_var_NonCashDividendTreatment_CASH_EQUIVALENT_set);
  SWIG_addvarlink(globals, "DividendComposition_EQUITY_AMOUNT_RECEIVER", Swig_var_DividendComposition_EQUITY_AMOUNT_RECEIVER_get, Swig_var_DividendComposition_EQUITY_AMOUNT_RECEIVER_set);
  SWIG_addvarlink(globals, "DividendComposition_CALCULATION_AGENT", Swig_var_DividendComposition_CALCULATION_AGENT_get, Swig_var_DividendComposition_CALCULATION_AGENT_set);
  SWIG_addvarlink(globals, "StrikeIndexQuote_BID", Swig_var_StrikeIndexQuote_BID_get, Swig_var_StrikeIndexQuote_BID_set);
  SWIG_addvarlink(globals, "StrikeIndexQuote_MID", Swig_var_StrikeIndexQuote_MID_get, Swig_var_StrikeIndexQuote_MID_set);
  SWIG_addvarlink(globals, "StrikeIndexQuote_OFFER", Swig_var_StrikeIndexQuote_OFFER_get, Swig_var_StrikeIndexQuote_OFFER_set);
  SWIG_addvarlink(globals, "ExtraordinaryEventAdjustmentMethod_CALCULATION_AGENT", Swig_var_ExtraordinaryEventAdjustmentMethod_CALCULATION_AGENT_get, Swig_var_ExtraordinaryEventAdjustmentMethod_CALCULATION_AGENT_set);
  SWIG_addvarlink(globals, "ExtraordinaryEventAdjustmentMethod_OPTIONS_EXCHANGE", Swig_var_ExtraordinaryEventAdjustmentMethod_OPTIONS_EXCHANGE_get, Swig_var_ExtraordinaryEventAdjustmentMethod_OPTIONS_EXCHANGE_set);
  SWIG_addvarlink(globals, "PaymentStreamInterpolationPeriod_INITIAL", Swig_var_PaymentStreamInterpolationPeriod_INITIAL_get, Swig_var_PaymentStreamInterpolationPeriod_INITIAL_set);
  SWIG_addvarlink(globals, "PaymentStreamInterpolationPeriod_INITIAL_AND_FINAL", Swig_var_PaymentStreamInterpolationPeriod_INITIAL_AND_FINAL_get, Swig_var_PaymentStreamInterpolationPeriod_INITIAL_AND_FINAL_set);
  SWIG_addvarlink(globals, "PaymentStreamInterpolationPeriod_FINAL", Swig_var_PaymentStreamInterpolationPeriod_FINAL_get, Swig_var_PaymentStreamInterpolationPeriod_FINAL_set);
  SWIG_addvarlink(globals, "PaymentStreamInterpolationPeriod_ANY_PERIOD", Swig_var_PaymentStreamInterpolationPeriod_ANY_PERIOD_get, Swig_var_PaymentStreamInterpolationPeriod_ANY_PERIOD_set);
  SWIG_addvarlink(globals, "PaymentStreamLinkStrikePriceType_VOLATILITY", Swig_var_PaymentStreamLinkStrikePriceType_VOLATILITY_get, Swig_var_PaymentStreamLinkStrikePriceType_VOLATILITY_set);
  SWIG_addvarlink(globals, "PaymentStreamLinkStrikePriceType_VARIANCE", Swig_var_PaymentStreamLinkStrikePriceType_VARIANCE_get, Swig_var_PaymentStreamLinkStrikePriceType_VARIANCE_set);
  SWIG_addvarlink(globals, "PaymentStreamRealizedVarianceMethod_PREVIOUS", Swig_var_PaymentStreamRealizedVarianceMethod_PREVIOUS_get, Swig_var_PaymentStreamRealizedVarianceMethod_PREVIOUS_set);
  SWIG_addvarlink(globals, "PaymentStreamRealizedVarianceMethod_LAST", Swig_var_PaymentStreamRealizedVarianceMethod_LAST_get, Swig_var_PaymentStreamRealizedVarianceMethod_LAST_set);
  SWIG_addvarlink(globals, "PaymentStreamRealizedVarianceMethod_BOTH", Swig_var_PaymentStreamRealizedVarianceMethod_BOTH_get, Swig_var_PaymentStreamRealizedVarianceMethod_BOTH_set);
  SWIG_addvarlink(globals, "ProvisionBreakFeeElection_FLAT_FEE", Swig_var_ProvisionBreakFeeElection_FLAT_FEE_get, Swig_var_ProvisionBreakFeeElection_FLAT_FEE_set);
  SWIG_addvarlink(globals, "ProvisionBreakFeeElection_AMORTIZED_FEE", Swig_var_ProvisionBreakFeeElection_AMORTIZED_FEE_get, Swig_var_ProvisionBreakFeeElection_AMORTIZED_FEE_set);
  SWIG_addvarlink(globals, "ProvisionBreakFeeElection_FUNDING_FEE", Swig_var_ProvisionBreakFeeElection_FUNDING_FEE_get, Swig_var_ProvisionBreakFeeElection_FUNDING_FEE_set);
  SWIG_addvarlink(globals, "ProvisionBreakFeeElection_FLAT_AND_FUNDING_FEE", Swig_var_ProvisionBreakFeeElection_FLAT_AND_FUNDING_FEE_get, Swig_var_ProvisionBreakFeeElection_FLAT_AND_FUNDING_FEE_set);
  SWIG_addvarlink(globals, "ProvisionBreakFeeElection_AMORTIZED_AND_FUNDING_FEE", Swig_var_ProvisionBreakFeeElection_AMORTIZED_AND_FUNDING_FEE_get, Swig_var_ProvisionBreakFeeElection_AMORTIZED_AND_FUNDING_FEE_set);
  SWIG_addvarlink(globals, "ReturnRateDateMode_PRICE_VALUATION", Swig_var_ReturnRateDateMode_PRICE_VALUATION_get, Swig_var_ReturnRateDateMode_PRICE_VALUATION_set);
  SWIG_addvarlink(globals, "ReturnRateDateMode_DIVIDEND_VALUATION", Swig_var_ReturnRateDateMode_DIVIDEND_VALUATION_get, Swig_var_ReturnRateDateMode_DIVIDEND_VALUATION_set);
  SWIG_addvarlink(globals, "ReturnRatePriceSequence_INITIAL", Swig_var_ReturnRatePriceSequence_INITIAL_get, Swig_var_ReturnRatePriceSequence_INITIAL_set);
  SWIG_addvarlink(globals, "ReturnRatePriceSequence_INTERIM", Swig_var_ReturnRatePriceSequence_INTERIM_get, Swig_var_ReturnRatePriceSequence_INTERIM_set);
  SWIG_addvarlink(globals, "ReturnRatePriceSequence_FINAL", Swig_var_ReturnRatePriceSequence_FINAL_get, Swig_var_ReturnRatePriceSequence_FINAL_set);
  SWIG_addvarlink(globals, "ReturnRateQuoteTimeType_OPEN", Swig_var_ReturnRateQuoteTimeType_OPEN_get, Swig_var_ReturnRateQuoteTimeType_OPEN_set);
  SWIG_addvarlink(globals, "ReturnRateQuoteTimeType_OFFICIAL_SETTL_PX", Swig_var_ReturnRateQuoteTimeType_OFFICIAL_SETTL_PX_get, Swig_var_ReturnRateQuoteTimeType_OFFICIAL_SETTL_PX_set);
  SWIG_addvarlink(globals, "ReturnRateQuoteTimeType_XETRA", Swig_var_ReturnRateQuoteTimeType_XETRA_get, Swig_var_ReturnRateQuoteTimeType_XETRA_set);
  SWIG_addvarlink(globals, "ReturnRateQuoteTimeType_CLOSE", Swig_var_ReturnRateQuoteTimeType_CLOSE_get, Swig_var_ReturnRateQuoteTimeType_CLOSE_set);
  SWIG_addvarlink(globals, "ReturnRateQuoteTimeType_DERIVATIVES_CLOSE", Swig_var_ReturnRateQuoteTimeType_DERIVATIVES_CLOSE_get, Swig_var_ReturnRateQuoteTimeType_DERIVATIVES_CLOSE_set);
  SWIG_addvarlink(globals, "ReturnRateQuoteTimeType_HIGH", Swig_var_ReturnRateQuoteTimeType_HIGH_get, Swig_var_ReturnRateQuoteTimeType_HIGH_set);
  SWIG_addvarlink(globals, "ReturnRateQuoteTimeType_LOW", Swig_var_ReturnRateQuoteTimeType_LOW_get, Swig_var_ReturnRateQuoteTimeType_LOW_set);
  SWIG_addvarlink(globals, "ReturnRateQuoteTimeType_AS_SPECIFIED_IN_MASTER_CONFIRMATION", Swig_var_ReturnRateQuoteTimeType_AS_SPECIFIED_IN_MASTER_CONFIRMATION_get, Swig_var_ReturnRateQuoteTimeType_AS_SPECIFIED_IN_MASTER_CONFIRMATION_set);
  SWIG_addvarlink(globals, "ReturnRateValuationPriceOption_NONE", Swig_var_ReturnRateValuationPriceOption_NONE_get, Swig_var_ReturnRateValuationPriceOption_NONE_set);
  SWIG_addvarlink(globals, "ReturnRateValuationPriceOption_FUTURES_PRICE", Swig_var_ReturnRateValuationPriceOption_FUTURES_PRICE_get, Swig_var_ReturnRateValuationPriceOption_FUTURES_PRICE_set);
  SWIG_addvarlink(globals, "ReturnRateValuationPriceOption_OPTIONS_PRICE", Swig_var_ReturnRateValuationPriceOption_OPTIONS_PRICE_get, Swig_var_ReturnRateValuationPriceOption_OPTIONS_PRICE_set);
  SWIG_addvarlink(globals, "ReturnRatePriceBasis_GROSS", Swig_var_ReturnRatePriceBasis_GROSS_get, Swig_var_ReturnRatePriceBasis_GROSS_set);
  SWIG_addvarlink(globals, "ReturnRatePriceBasis_NET", Swig_var_ReturnRatePriceBasis_NET_get, Swig_var_ReturnRatePriceBasis_NET_set);
  SWIG_addvarlink(globals, "ReturnRatePriceBasis_ACCRUED", Swig_var_ReturnRatePriceBasis_ACCRUED_get, Swig_var_ReturnRatePriceBasis_ACCRUED_set);
  SWIG_addvarlink(globals, "ReturnRatePriceBasis_CLEAN_NET", Swig_var_ReturnRatePriceBasis_CLEAN_NET_get, Swig_var_ReturnRatePriceBasis_CLEAN_NET_set);
  SWIG_addvarlink(globals, "ReturnRatePriceType_ABSOLUTE_TERMS", Swig_var_ReturnRatePriceType_ABSOLUTE_TERMS_get, Swig_var_ReturnRatePriceType_ABSOLUTE_TERMS_set);
  SWIG_addvarlink(globals, "ReturnRatePriceType_PERCENTAGE_OF_NOTIONAL", Swig_var_ReturnRatePriceType_PERCENTAGE_OF_NOTIONAL_get, Swig_var_ReturnRatePriceType_PERCENTAGE_OF_NOTIONAL_set);
  SWIG_addvarlink(globals, "StreamNotionalAdjustments_EXECUTION", Swig_var_StreamNotionalAdjustments_EXECUTION_get, Swig_var_StreamNotionalAdjustments_EXECUTION_set);
  SWIG_addvarlink(globals, "StreamNotionalAdjustments_PORTFOLIO_REBALANCING", Swig_var_StreamNotionalAdjustments_PORTFOLIO_REBALANCING_get, Swig_var_StreamNotionalAdjustments_PORTFOLIO_REBALANCING_set);
  SWIG_addvarlink(globals, "StreamNotionalAdjustments_STANDARD", Swig_var_StreamNotionalAdjustments_STANDARD_get, Swig_var_StreamNotionalAdjustments_STANDARD_set);
  SWIG_addvarlink(globals, "UnderlyingNotionalAdjustments_EXECUTION", Swig_var_UnderlyingNotionalAdjustments_EXECUTION_get, Swig_var_UnderlyingNotionalAdjustments_EXECUTION_set);
  SWIG_addvarlink(globals, "UnderlyingNotionalAdjustments_PORTFOLIO_REBALANCING", Swig_var_UnderlyingNotionalAdjustments_PORTFOLIO_REBALANCING_get, Swig_var_UnderlyingNotionalAdjustments_PORTFOLIO_REBALANCING_set);
  SWIG_addvarlink(globals, "UnderlyingNotionalAdjustments_STANDARD", Swig_var_UnderlyingNotionalAdjustments_STANDARD_get, Swig_var_UnderlyingNotionalAdjustments_STANDARD_set);
  SWIG_addvarlink(globals, "RemunerationIndicator_NO_REMUNERATION_PAID", Swig_var_RemunerationIndicator_NO_REMUNERATION_PAID_get, Swig_var_RemunerationIndicator_NO_REMUNERATION_PAID_set);
  SWIG_addvarlink(globals, "RemunerationIndicator_REMUNERATION_PAID", Swig_var_RemunerationIndicator_REMUNERATION_PAID_get, Swig_var_RemunerationIndicator_REMUNERATION_PAID_set);
  SWIG_addvarlink(globals, "PartyRiskLimitStatus_DISABLED", Swig_var_PartyRiskLimitStatus_DISABLED_get, Swig_var_PartyRiskLimitStatus_DISABLED_set);
  SWIG_addvarlink(globals, "PartyRiskLimitStatus_ENABLED", Swig_var_PartyRiskLimitStatus_ENABLED_get, Swig_var_PartyRiskLimitStatus_ENABLED_set);
  SWIG_addvarlink(globals, "AlgorithmicTradeIndicator_NON_ALGORITHMIC_TRADE", Swig_var_AlgorithmicTradeIndicator_NON_ALGORITHMIC_TRADE_get, Swig_var_AlgorithmicTradeIndicator_NON_ALGORITHMIC_TRADE_set);
  SWIG_addvarlink(globals, "AlgorithmicTradeIndicator_ALGORITHMIC_TRADE", Swig_var_AlgorithmicTradeIndicator_ALGORITHMIC_TRADE_get, Swig_var_AlgorithmicTradeIndicator_ALGORITHMIC_TRADE_set);
  SWIG_addvarlink(globals, "TrdRegPublicationType_PRE_TRADE_TRANSPARENCY_WAIVER", Swig_var_TrdRegPublicationType_PRE_TRADE_TRANSPARENCY_WAIVER_get, Swig_var_TrdRegPublicationType_PRE_TRADE_TRANSPARENCY_WAIVER_set);
  SWIG_addvarlink(globals, "TrdRegPublicationType_POST_TRADE_DEFERRAL", Swig_var_TrdRegPublicationType_POST_TRADE_DEFERRAL_get, Swig_var_TrdRegPublicationType_POST_TRADE_DEFERRAL_set);
  SWIG_addvarlink(globals, "TrdRegPublicationType_EXEMPT_FROM_PUBLICATION", Swig_var_TrdRegPublicationType_EXEMPT_FROM_PUBLICATION_get, Swig_var_TrdRegPublicationType_EXEMPT_FROM_PUBLICATION_set);
  SWIG_addvarlink(globals, "TrdRegPublicationType_ORDER_LEVEL_PUBLICATION_TO_SUBSCRIBERS", Swig_var_TrdRegPublicationType_ORDER_LEVEL_PUBLICATION_TO_SUBSCRIBERS_get, Swig_var_TrdRegPublicationType_ORDER_LEVEL_PUBLICATION_TO_SUBSCRIBERS_set);
  SWIG_addvarlink(globals, "TrdRegPublicationType_PRICE_LEVEL_PUBLICATION_TO_SUBSCRIBERS", Swig_var_TrdRegPublicationType_PRICE_LEVEL_PUBLICATION_TO_SUBSCRIBERS_get, Swig_var_TrdRegPublicationType_PRICE_LEVEL_PUBLICATION_TO_SUBSCRIBERS_set);
  SWIG_addvarlink(globals, "TrdRegPublicationType_ORDER_LEVEL_PUBLICATION_TO_THE_PUBLIC", Swig_var_TrdRegPublicationType_ORDER_LEVEL_PUBLICATION_TO_THE_PUBLIC_get, Swig_var_TrdRegPublicationType_ORDER_LEVEL_PUBLICATION_TO_THE_PUBLIC_set);
  SWIG_addvarlink(globals, "TrdRegPublicationType_PUBLICATION_INTERNAL_TO_EXECUTION_VENUE", Swig_var_TrdRegPublicationType_PUBLICATION_INTERNAL_TO_EXECUTION_VENUE_get, Swig_var_TrdRegPublicationType_PUBLICATION_INTERNAL_TO_EXECUTION_VENUE_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_AVERAGE_SPREAD_PRICE", Swig_var_TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_AVERAGE_SPREAD_PRICE_get, Swig_var_TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_AVERAGE_SPREAD_PRICE_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_REF_PRICE", Swig_var_TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_REF_PRICE_get, Swig_var_TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_REF_PRICE_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_OTHER_CONDITIONS", Swig_var_TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_OTHER_CONDITIONS_get, Swig_var_TrdRegPublicationReason_NO_BOOK_ORDER_DUE_TO_OTHER_CONDITIONS_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_REF_PRICE", Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_REF_PRICE_get, Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_REF_PRICE_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_ILLIQUID", Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_ILLIQUID_get, Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_ILLIQUID_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_ORDER_SIZE", Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_ORDER_SIZE_get, Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_ORDER_SIZE_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_DEFERRAL_DUE_TO_LARGE_IN_SCALE", Swig_var_TrdRegPublicationReason_DEFERRAL_DUE_TO_LARGE_IN_SCALE_get, Swig_var_TrdRegPublicationReason_DEFERRAL_DUE_TO_LARGE_IN_SCALE_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_DEFERRAL_DUE_TO_ILLIQUID", Swig_var_TrdRegPublicationReason_DEFERRAL_DUE_TO_ILLIQUID_get, Swig_var_TrdRegPublicationReason_DEFERRAL_DUE_TO_ILLIQUID_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_DEFERRAL_DUE_TO_SIZE_SPECIFIC", Swig_var_TrdRegPublicationReason_DEFERRAL_DUE_TO_SIZE_SPECIFIC_get, Swig_var_TrdRegPublicationReason_DEFERRAL_DUE_TO_SIZE_SPECIFIC_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_LARGE_IN_SCALE", Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_LARGE_IN_SCALE_get, Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_DUE_TO_LARGE_IN_SCALE_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_NO_PUBLIC_PRICE_SIZE_DUE_TO_ORDER_HIDDEN", Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_SIZE_DUE_TO_ORDER_HIDDEN_get, Swig_var_TrdRegPublicationReason_NO_PUBLIC_PRICE_SIZE_DUE_TO_ORDER_HIDDEN_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_EXEMPTED_DUE_TO_SECURITIES_FINANCING_TRANSACTION", Swig_var_TrdRegPublicationReason_EXEMPTED_DUE_TO_SECURITIES_FINANCING_TRANSACTION_get, Swig_var_TrdRegPublicationReason_EXEMPTED_DUE_TO_SECURITIES_FINANCING_TRANSACTION_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_EXEMPTED_DUE_TO_ESCB_POLICY_TRANSACTION", Swig_var_TrdRegPublicationReason_EXEMPTED_DUE_TO_ESCB_POLICY_TRANSACTION_get, Swig_var_TrdRegPublicationReason_EXEMPTED_DUE_TO_ESCB_POLICY_TRANSACTION_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_EXCEPTION_DUE_TO_REPORT_BY_PAPER", Swig_var_TrdRegPublicationReason_EXCEPTION_DUE_TO_REPORT_BY_PAPER_get, Swig_var_TrdRegPublicationReason_EXCEPTION_DUE_TO_REPORT_BY_PAPER_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_EXCEPTION_DUE_TO_TRADE_EXECUTED_WITH_NON_REPORTING_PARTY", Swig_var_TrdRegPublicationReason_EXCEPTION_DUE_TO_TRADE_EXECUTED_WITH_NON_REPORTING_PARTY_get, Swig_var_TrdRegPublicationReason_EXCEPTION_DUE_TO_TRADE_EXECUTED_WITH_NON_REPORTING_PARTY_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_EXCEPTION_DUE_TO_INTRA_FIRM_ORDER", Swig_var_TrdRegPublicationReason_EXCEPTION_DUE_TO_INTRA_FIRM_ORDER_get, Swig_var_TrdRegPublicationReason_EXCEPTION_DUE_TO_INTRA_FIRM_ORDER_set);
  SWIG_addvarlink(globals, "TrdRegPublicationReason_REPORTED_OUTSIDE_REPORTING_HOURS", Swig_var_TrdRegPublicationReason_REPORTED_OUTSIDE_REPORTING_HOURS_get, Swig_var_TrdRegPublicationReason_REPORTED_OUTSIDE_REPORTING_HOURS_set);
  SWIG_addvarlink(globals, "CrossedIndicator_NO_CROSS", Swig_var_CrossedIndicator_NO_CROSS_get, Swig_var_CrossedIndicator_NO_CROSS_set);
  SWIG_addvarlink(globals, "CrossedIndicator_CROSS_REJECTED", Swig_var_CrossedIndicator_CROSS_REJECTED_get, Swig_var_CrossedIndicator_CROSS_REJECTED_set);
  SWIG_addvarlink(globals, "CrossedIndicator_CROSS_ACCEPTED", Swig_var_CrossedIndicator_CROSS_ACCEPTED_get, Swig_var_CrossedIndicator_CROSS_ACCEPTED_set);
  SWIG_addvarlink(globals, "OrderAttributeType_AGGREGATED_ORDER", Swig_var_OrderAttributeType_AGGREGATED_ORDER_get, Swig_var_OrderAttributeType_AGGREGATED_ORDER_set);
  SWIG_addvarlink(globals, "OrderAttributeType_PENDING_ALLOCATION", Swig_var_OrderAttributeType_PENDING_ALLOCATION_get, Swig_var_OrderAttributeType_PENDING_ALLOCATION_set);
  SWIG_addvarlink(globals, "OrderAttributeType_LIQUIDITY_PROVISION_ACTIVITY_ORDER", Swig_var_OrderAttributeType_LIQUIDITY_PROVISION_ACTIVITY_ORDER_get, Swig_var_OrderAttributeType_LIQUIDITY_PROVISION_ACTIVITY_ORDER_set);
  SWIG_addvarlink(globals, "OrderAttributeType_RISK_REDUCTION_ORDER", Swig_var_OrderAttributeType_RISK_REDUCTION_ORDER_get, Swig_var_OrderAttributeType_RISK_REDUCTION_ORDER_set);
  SWIG_addvarlink(globals, "OrderAttributeType_ALGORITHMIC_ORDER", Swig_var_OrderAttributeType_ALGORITHMIC_ORDER_get, Swig_var_OrderAttributeType_ALGORITHMIC_ORDER_set);
  SWIG_addvarlink(globals, "OrderAttributeType_SYSTEMATIC_INTERNALISER_ORDER", Swig_var_OrderAttributeType_SYSTEMATIC_INTERNALISER_ORDER_get, Swig_var_OrderAttributeType_SYSTEMATIC_INTERNALISER_ORDER_set);
  SWIG_addvarlink(globals, "OrderAttributeType_ALL_EXECUTIONS_SUBMITTED_TO_APA", Swig_var_OrderAttributeType_ALL_EXECUTIONS_SUBMITTED_TO_APA_get, Swig_var_OrderAttributeType_ALL_EXECUTIONS_SUBMITTED_TO_APA_set);
  SWIG_addvarlink(globals, "OrderAttributeType_ORDER_EXECUTION_INSTRUCTED_BY_CLIENT", Swig_var_OrderAttributeType_ORDER_EXECUTION_INSTRUCTED_BY_CLIENT_get, Swig_var_OrderAttributeType_ORDER_EXECUTION_INSTRUCTED_BY_CLIENT_set);
  SWIG_addvarlink(globals, "OrderAttributeType_LARGE_IN_SCALE", Swig_var_OrderAttributeType_LARGE_IN_SCALE_get, Swig_var_OrderAttributeType_LARGE_IN_SCALE_set);
  SWIG_addvarlink(globals, "OrderAttributeType_HIDDEN", Swig_var_OrderAttributeType_HIDDEN_get, Swig_var_OrderAttributeType_HIDDEN_set);
  SWIG_addvarlink(globals, "OrderAttributeType_SUBJECT_TO_EUSTO", Swig_var_OrderAttributeType_SUBJECT_TO_EUSTO_get, Swig_var_OrderAttributeType_SUBJECT_TO_EUSTO_set);
  SWIG_addvarlink(globals, "OrderAttributeType_SUBJECT_TO_UKSTO", Swig_var_OrderAttributeType_SUBJECT_TO_UKSTO_get, Swig_var_OrderAttributeType_SUBJECT_TO_UKSTO_set);
  SWIG_addvarlink(globals, "OrderAttributeType_REPRESENTATIVE_ORDER", Swig_var_OrderAttributeType_REPRESENTATIVE_ORDER_get, Swig_var_OrderAttributeType_REPRESENTATIVE_ORDER_set);
  SWIG_addvarlink(globals, "OrderAttributeType_LINKAGE_TYPE", Swig_var_OrderAttributeType_LINKAGE_TYPE_get, Swig_var_OrderAttributeType_LINKAGE_TYPE_set);
  SWIG_addvarlink(globals, "OrderAttributeType_EXEMPT_FROM_STO", Swig_var_OrderAttributeType_EXEMPT_FROM_STO_get, Swig_var_OrderAttributeType_EXEMPT_FROM_STO_set);
  SWIG_addvarlink(globals, "TradeReportingIndicator_NOT_REPORTED", Swig_var_TradeReportingIndicator_NOT_REPORTED_get, Swig_var_TradeReportingIndicator_NOT_REPORTED_set);
  SWIG_addvarlink(globals, "TradeReportingIndicator_ON_BOOK", Swig_var_TradeReportingIndicator_ON_BOOK_get, Swig_var_TradeReportingIndicator_ON_BOOK_set);
  SWIG_addvarlink(globals, "TradeReportingIndicator_SI_SELLER", Swig_var_TradeReportingIndicator_SI_SELLER_get, Swig_var_TradeReportingIndicator_SI_SELLER_set);
  SWIG_addvarlink(globals, "TradeReportingIndicator_SI_BUYER", Swig_var_TradeReportingIndicator_SI_BUYER_get, Swig_var_TradeReportingIndicator_SI_BUYER_set);
  SWIG_addvarlink(globals, "TradeReportingIndicator_NON_SI_SELLER", Swig_var_TradeReportingIndicator_NON_SI_SELLER_get, Swig_var_TradeReportingIndicator_NON_SI_SELLER_set);
  SWIG_addvarlink(globals, "TradeReportingIndicator_SUB_DELEGATION_BY_FIRM", Swig_var_TradeReportingIndicator_SUB_DELEGATION_BY_FIRM_get, Swig_var_TradeReportingIndicator_SUB_DELEGATION_BY_FIRM_set);
  SWIG_addvarlink(globals, "TradeReportingIndicator_REPORTABLE", Swig_var_TradeReportingIndicator_REPORTABLE_get, Swig_var_TradeReportingIndicator_REPORTABLE_set);
  SWIG_addvarlink(globals, "TradeReportingIndicator_NON_SI_BUYER", Swig_var_TradeReportingIndicator_NON_SI_BUYER_get, Swig_var_TradeReportingIndicator_NON_SI_BUYER_set);
  SWIG_addvarlink(globals, "TradeReportingIndicator_OFF_BOOK", Swig_var_TradeReportingIndicator_OFF_BOOK_get, Swig_var_TradeReportingIndicator_OFF_BOOK_set);
  SWIG_addvarlink(globals, "TradeReportingIndicator_NOT_REPORTABLE", Swig_var_TradeReportingIndicator_NOT_REPORTABLE_get, Swig_var_TradeReportingIndicator_NOT_REPORTABLE_set);
  SWIG_addvarlink(globals, "MassActionReason_NONE", Swig_var_MassActionReason_NONE_get, Swig_var_MassActionReason_NONE_set);
  SWIG_addvarlink(globals, "MassActionReason_TRADING_RISK_CONTROL", Swig_var_MassActionReason_TRADING_RISK_CONTROL_get, Swig_var_MassActionReason_TRADING_RISK_CONTROL_set);
  SWIG_addvarlink(globals, "MassActionReason_CLEARING_RISK_CONTROL", Swig_var_MassActionReason_CLEARING_RISK_CONTROL_get, Swig_var_MassActionReason_CLEARING_RISK_CONTROL_set);
  SWIG_addvarlink(globals, "MassActionReason_MARKET_MAKER_PROTECTION", Swig_var_MassActionReason_MARKET_MAKER_PROTECTION_get, Swig_var_MassActionReason_MARKET_MAKER_PROTECTION_set);
  SWIG_addvarlink(globals, "MassActionReason_STOP_TRADING", Swig_var_MassActionReason_STOP_TRADING_get, Swig_var_MassActionReason_STOP_TRADING_set);
  SWIG_addvarlink(globals, "MassActionReason_EMERGENCY_ACTION", Swig_var_MassActionReason_EMERGENCY_ACTION_get, Swig_var_MassActionReason_EMERGENCY_ACTION_set);
  SWIG_addvarlink(globals, "MassActionReason_SESSION_LOSS_LOGOUT", Swig_var_MassActionReason_SESSION_LOSS_LOGOUT_get, Swig_var_MassActionReason_SESSION_LOSS_LOGOUT_set);
  SWIG_addvarlink(globals, "MassActionReason_DUPLICATE_LOGIN", Swig_var_MassActionReason_DUPLICATE_LOGIN_get, Swig_var_MassActionReason_DUPLICATE_LOGIN_set);
  SWIG_addvarlink(globals, "MassActionReason_PRODUCT_NOT_TRADED", Swig_var_MassActionReason_PRODUCT_NOT_TRADED_get, Swig_var_MassActionReason_PRODUCT_NOT_TRADED_set);
  SWIG_addvarlink(globals, "MassActionReason_INSTRUMENT_NOT_TRADED", Swig_var_MassActionReason_INSTRUMENT_NOT_TRADED_get, Swig_var_MassActionReason_INSTRUMENT_NOT_TRADED_set);
  SWIG_addvarlink(globals, "MassActionReason_COMPLE_INSTRUMENT_DELETED", Swig_var_MassActionReason_COMPLE_INSTRUMENT_DELETED_get, Swig_var_MassActionReason_COMPLE_INSTRUMENT_DELETED_set);
  SWIG_addvarlink(globals, "MassActionReason_CIRCUIT_BREAKER_ACTIVATED", Swig_var_MassActionReason_CIRCUIT_BREAKER_ACTIVATED_get, Swig_var_MassActionReason_CIRCUIT_BREAKER_ACTIVATED_set);
  SWIG_addvarlink(globals, "MassActionReason_OTHER", Swig_var_MassActionReason_OTHER_get, Swig_var_MassActionReason_OTHER_set);
  SWIG_addvarlink(globals, "NotAffectedReason_ORDER_SUSPENDED", Swig_var_NotAffectedReason_ORDER_SUSPENDED_get, Swig_var_NotAffectedReason_ORDER_SUSPENDED_set);
  SWIG_addvarlink(globals, "NotAffectedReason_INSTRUMENT_SUSPENDED", Swig_var_NotAffectedReason_INSTRUMENT_SUSPENDED_get, Swig_var_NotAffectedReason_INSTRUMENT_SUSPENDED_set);
  SWIG_addvarlink(globals, "OrderOwnershipIndicator_NO_CHANGE", Swig_var_OrderOwnershipIndicator_NO_CHANGE_get, Swig_var_OrderOwnershipIndicator_NO_CHANGE_set);
  SWIG_addvarlink(globals, "OrderOwnershipIndicator_EXECUTING_PARTY_CHANGE", Swig_var_OrderOwnershipIndicator_EXECUTING_PARTY_CHANGE_get, Swig_var_OrderOwnershipIndicator_EXECUTING_PARTY_CHANGE_set);
  SWIG_addvarlink(globals, "OrderOwnershipIndicator_ENTERING_PARTY_CHANGE", Swig_var_OrderOwnershipIndicator_ENTERING_PARTY_CHANGE_get, Swig_var_OrderOwnershipIndicator_ENTERING_PARTY_CHANGE_set);
  SWIG_addvarlink(globals, "OrderOwnershipIndicator_SPECIFIED_PARTY_CHANGE", Swig_var_OrderOwnershipIndicator_SPECIFIED_PARTY_CHANGE_get, Swig_var_OrderOwnershipIndicator_SPECIFIED_PARTY_CHANGE_set);
  SWIG_addvarlink(globals, "InTheMoneyCondition_STANDARD_ITM", Swig_var_InTheMoneyCondition_STANDARD_ITM_get, Swig_var_InTheMoneyCondition_STANDARD_ITM_set);
  SWIG_addvarlink(globals, "InTheMoneyCondition_ATMITM", Swig_var_InTheMoneyCondition_ATMITM_get, Swig_var_InTheMoneyCondition_ATMITM_set);
  SWIG_addvarlink(globals, "InTheMoneyCondition_ATM_CALL_ITM", Swig_var_InTheMoneyCondition_ATM_CALL_ITM_get, Swig_var_InTheMoneyCondition_ATM_CALL_ITM_set);
  SWIG_addvarlink(globals, "InTheMoneyCondition_ATM_PUT_ITM", Swig_var_InTheMoneyCondition_ATM_PUT_ITM_get, Swig_var_InTheMoneyCondition_ATM_PUT_ITM_set);
  SWIG_addvarlink(globals, "ExDestinationType_NO_RESTRICTION", Swig_var_ExDestinationType_NO_RESTRICTION_get, Swig_var_ExDestinationType_NO_RESTRICTION_set);
  SWIG_addvarlink(globals, "ExDestinationType_TRADED_ONLY_ON_TRADING_VENUE", Swig_var_ExDestinationType_TRADED_ONLY_ON_TRADING_VENUE_get, Swig_var_ExDestinationType_TRADED_ONLY_ON_TRADING_VENUE_set);
  SWIG_addvarlink(globals, "ExDestinationType_TRADED_ONLY_ON_SI", Swig_var_ExDestinationType_TRADED_ONLY_ON_SI_get, Swig_var_ExDestinationType_TRADED_ONLY_ON_SI_set);
  SWIG_addvarlink(globals, "ExDestinationType_TRADED_ON_TRADING_VENUE_OR_SI", Swig_var_ExDestinationType_TRADED_ON_TRADING_VENUE_OR_SI_get, Swig_var_ExDestinationType_TRADED_ON_TRADING_VENUE_OR_SI_set);
  SWIG_addvarlink(globals, "MarketCondition_NORMAL", Swig_var_MarketCondition_NORMAL_get, Swig_var_MarketCondition_NORMAL_set);
  SWIG_addvarlink(globals, "MarketCondition_STRESSED", Swig_var_MarketCondition_STRESSED_get, Swig_var_MarketCondition_STRESSED_set);
  SWIG_addvarlink(globals, "MarketCondition_EXCEPTIONAL", Swig_var_MarketCondition_EXCEPTIONAL_get, Swig_var_MarketCondition_EXCEPTIONAL_set);
  SWIG_addvarlink(globals, "QuoteAttributeType_QUOTE_ABOVE_STANDARD_MARKET_SIZE", Swig_var_QuoteAttributeType_QUOTE_ABOVE_STANDARD_MARKET_SIZE_get, Swig_var_QuoteAttributeType_QUOTE_ABOVE_STANDARD_MARKET_SIZE_set);
  SWIG_addvarlink(globals, "QuoteAttributeType_QUOTE_ABOVE_SPECIFIC_INSTRUMENT_SIZE", Swig_var_QuoteAttributeType_QUOTE_ABOVE_SPECIFIC_INSTRUMENT_SIZE_get, Swig_var_QuoteAttributeType_QUOTE_ABOVE_SPECIFIC_INSTRUMENT_SIZE_set);
  SWIG_addvarlink(globals, "QuoteAttributeType_QUOTE_APPLICABLE_FOR_LIQUIDTY_PROVISION_ACTIVITY", Swig_var_QuoteAttributeType_QUOTE_APPLICABLE_FOR_LIQUIDTY_PROVISION_ACTIVITY_get, Swig_var_QuoteAttributeType_QUOTE_APPLICABLE_FOR_LIQUIDTY_PROVISION_ACTIVITY_set);
  SWIG_addvarlink(globals, "QuoteAttributeType_QUOTE_ISSUER_STATUS", Swig_var_QuoteAttributeType_QUOTE_ISSUER_STATUS_get, Swig_var_QuoteAttributeType_QUOTE_ISSUER_STATUS_set);
  SWIG_addvarlink(globals, "QuoteAttributeType_BID_OR_ASK_REQUEST", Swig_var_QuoteAttributeType_BID_OR_ASK_REQUEST_get, Swig_var_QuoteAttributeType_BID_OR_ASK_REQUEST_set);
  SWIG_addvarlink(globals, "PriceQualifier_ACCRUED_INTEREST_IS_FACTORED", Swig_var_PriceQualifier_ACCRUED_INTEREST_IS_FACTORED_get, Swig_var_PriceQualifier_ACCRUED_INTEREST_IS_FACTORED_set);
  SWIG_addvarlink(globals, "PriceQualifier_TAX_IS_FACTORED", Swig_var_PriceQualifier_TAX_IS_FACTORED_get, Swig_var_PriceQualifier_TAX_IS_FACTORED_set);
  SWIG_addvarlink(globals, "PriceQualifier_BOND_AMORTIZATION_IS_FACTORED", Swig_var_PriceQualifier_BOND_AMORTIZATION_IS_FACTORED_get, Swig_var_PriceQualifier_BOND_AMORTIZATION_IS_FACTORED_set);
  SWIG_addvarlink(globals, "MDValueTier_RANGE1", Swig_var_MDValueTier_RANGE1_get, Swig_var_MDValueTier_RANGE1_set);
  SWIG_addvarlink(globals, "MDValueTier_RANGE2", Swig_var_MDValueTier_RANGE2_get, Swig_var_MDValueTier_RANGE2_set);
  SWIG_addvarlink(globals, "MDValueTier_RANGE3", Swig_var_MDValueTier_RANGE3_get, Swig_var_MDValueTier_RANGE3_set);
  SWIG_addvarlink(globals, "MiscFeeQualifier_CONTRIBUTES", Swig_var_MiscFeeQualifier_CONTRIBUTES_get, Swig_var_MiscFeeQualifier_CONTRIBUTES_set);
  SWIG_addvarlink(globals, "MiscFeeQualifier_DOES_NOT_CONTRIBUTE", Swig_var_MiscFeeQualifier_DOES_NOT_CONTRIBUTE_get, Swig_var_MiscFeeQualifier_DOES_NOT_CONTRIBUTE_set);
  SWIG_addvarlink(globals, "CommissionAmountSubType_RESEARCH_PAYMENT_ACCOUNT", Swig_var_CommissionAmountSubType_RESEARCH_PAYMENT_ACCOUNT_get, Swig_var_CommissionAmountSubType_RESEARCH_PAYMENT_ACCOUNT_set);
  SWIG_addvarlink(globals, "CommissionAmountSubType_COMMISSION_SHARING_AGREEMENT", Swig_var_CommissionAmountSubType_COMMISSION_SHARING_AGREEMENT_get, Swig_var_CommissionAmountSubType_COMMISSION_SHARING_AGREEMENT_set);
  SWIG_addvarlink(globals, "CommissionAmountSubType_OTHER_TYPE_RESEARCH_PAYMENT", Swig_var_CommissionAmountSubType_OTHER_TYPE_RESEARCH_PAYMENT_get, Swig_var_CommissionAmountSubType_OTHER_TYPE_RESEARCH_PAYMENT_set);
  SWIG_addvarlink(globals, "CommodityFinalPriceType_ARGUS_MC_CLOSKEY", Swig_var_CommodityFinalPriceType_ARGUS_MC_CLOSKEY_get, Swig_var_CommodityFinalPriceType_ARGUS_MC_CLOSKEY_set);
  SWIG_addvarlink(globals, "CommodityFinalPriceType_BALTIC", Swig_var_CommodityFinalPriceType_BALTIC_get, Swig_var_CommodityFinalPriceType_BALTIC_set);
  SWIG_addvarlink(globals, "CommodityFinalPriceType_EXCHANGE", Swig_var_CommodityFinalPriceType_EXCHANGE_get, Swig_var_CommodityFinalPriceType_EXCHANGE_set);
  SWIG_addvarlink(globals, "CommodityFinalPriceType_GLOBAL_COAL", Swig_var_CommodityFinalPriceType_GLOBAL_COAL_get, Swig_var_CommodityFinalPriceType_GLOBAL_COAL_set);
  SWIG_addvarlink(globals, "CommodityFinalPriceType_IHS_MC_CLOSKEY", Swig_var_CommodityFinalPriceType_IHS_MC_CLOSKEY_get, Swig_var_CommodityFinalPriceType_IHS_MC_CLOSKEY_set);
  SWIG_addvarlink(globals, "CommodityFinalPriceType_PLATTS", Swig_var_CommodityFinalPriceType_PLATTS_get, Swig_var_CommodityFinalPriceType_PLATTS_set);
  SWIG_addvarlink(globals, "CommodityFinalPriceType_OTHER", Swig_var_CommodityFinalPriceType_OTHER_get, Swig_var_CommodityFinalPriceType_OTHER_set);
  SWIG_addvarlink(globals, "ReferenceDataDateType_ADMIT_TO_TRADE_REQUEST_DATE", Swig_var_ReferenceDataDateType_ADMIT_TO_TRADE_REQUEST_DATE_get, Swig_var_ReferenceDataDateType_ADMIT_TO_TRADE_REQUEST_DATE_set);
  SWIG_addvarlink(globals, "ReferenceDataDateType_ADMIT_TO_TRADE_APPROVAL_DATE", Swig_var_ReferenceDataDateType_ADMIT_TO_TRADE_APPROVAL_DATE_get, Swig_var_ReferenceDataDateType_ADMIT_TO_TRADE_APPROVAL_DATE_set);
  SWIG_addvarlink(globals, "ReferenceDataDateType_ADMIT_TO_TRADE_OR_FIRST_TRADE_DATE", Swig_var_ReferenceDataDateType_ADMIT_TO_TRADE_OR_FIRST_TRADE_DATE_get, Swig_var_ReferenceDataDateType_ADMIT_TO_TRADE_OR_FIRST_TRADE_DATE_set);
  SWIG_addvarlink(globals, "ReferenceDataDateType_TERMINATION_DATE", Swig_var_ReferenceDataDateType_TERMINATION_DATE_get, Swig_var_ReferenceDataDateType_TERMINATION_DATE_set);
  SWIG_addvarlink(globals, "ReturnTrigger_DIVIDEND", Swig_var_ReturnTrigger_DIVIDEND_get, Swig_var_ReturnTrigger_DIVIDEND_set);
  SWIG_addvarlink(globals, "ReturnTrigger_VARIANCE", Swig_var_ReturnTrigger_VARIANCE_get, Swig_var_ReturnTrigger_VARIANCE_set);
  SWIG_addvarlink(globals, "ReturnTrigger_VOLATILITY", Swig_var_ReturnTrigger_VOLATILITY_get, Swig_var_ReturnTrigger_VOLATILITY_set);
  SWIG_addvarlink(globals, "ReturnTrigger_TOTAL_RETURN", Swig_var_ReturnTrigger_TOTAL_RETURN_get, Swig_var_ReturnTrigger_TOTAL_RETURN_set);
  SWIG_addvarlink(globals, "ReturnTrigger_CONTRACT_FOR_DIFFERENCE", Swig_var_ReturnTrigger_CONTRACT_FOR_DIFFERENCE_get, Swig_var_ReturnTrigger_CONTRACT_FOR_DIFFERENCE_set);
  SWIG_addvarlink(globals, "ReturnTrigger_CREDIT_DEFAULT", Swig_var_ReturnTrigger_CREDIT_DEFAULT_get, Swig_var_ReturnTrigger_CREDIT_DEFAULT_set);
  SWIG_addvarlink(globals, "ReturnTrigger_SPREAD_BET", Swig_var_ReturnTrigger_SPREAD_BET_get, Swig_var_ReturnTrigger_SPREAD_BET_set);
  SWIG_addvarlink(globals, "ReturnTrigger_PRICE", Swig_var_ReturnTrigger_PRICE_get, Swig_var_ReturnTrigger_PRICE_set);
  SWIG_addvarlink(globals, "ReturnTrigger_FORWARD_PRICE_UNDERLYING_INSTRUMENT", Swig_var_ReturnTrigger_FORWARD_PRICE_UNDERLYING_INSTRUMENT_get, Swig_var_ReturnTrigger_FORWARD_PRICE_UNDERLYING_INSTRUMENT_set);
  SWIG_addvarlink(globals, "ReturnTrigger_OTHER", Swig_var_ReturnTrigger_OTHER_get, Swig_var_ReturnTrigger_OTHER_set);
  SWIG_addvarlink(globals, "AveragePriceType_TIME_WEIGHTED_AVERAGE_PRICE", Swig_var_AveragePriceType_TIME_WEIGHTED_AVERAGE_PRICE_get, Swig_var_AveragePriceType_TIME_WEIGHTED_AVERAGE_PRICE_set);
  SWIG_addvarlink(globals, "AveragePriceType_VOLUME_WEIGHTED_AVERAGE_PRICE", Swig_var_AveragePriceType_VOLUME_WEIGHTED_AVERAGE_PRICE_get, Swig_var_AveragePriceType_VOLUME_WEIGHTED_AVERAGE_PRICE_set);
  SWIG_addvarlink(globals, "AveragePriceType_PERCENT_OF_VOLUME_AVERAGE_PRICE", Swig_var_AveragePriceType_PERCENT_OF_VOLUME_AVERAGE_PRICE_get, Swig_var_AveragePriceType_PERCENT_OF_VOLUME_AVERAGE_PRICE_set);
  SWIG_addvarlink(globals, "AveragePriceType_LIMIT_ORDER_AVERAGE_PRICE", Swig_var_AveragePriceType_LIMIT_ORDER_AVERAGE_PRICE_get, Swig_var_AveragePriceType_LIMIT_ORDER_AVERAGE_PRICE_set);
  SWIG_addvarlink(globals, "AllocGroupStatus_ADDED", Swig_var_AllocGroupStatus_ADDED_get, Swig_var_AllocGroupStatus_ADDED_set);
  SWIG_addvarlink(globals, "AllocGroupStatus_CANCELED", Swig_var_AllocGroupStatus_CANCELED_get, Swig_var_AllocGroupStatus_CANCELED_set);
  SWIG_addvarlink(globals, "AllocGroupStatus_REPLACED", Swig_var_AllocGroupStatus_REPLACED_get, Swig_var_AllocGroupStatus_REPLACED_set);
  SWIG_addvarlink(globals, "AllocGroupStatus_CHANGED", Swig_var_AllocGroupStatus_CHANGED_get, Swig_var_AllocGroupStatus_CHANGED_set);
  SWIG_addvarlink(globals, "AllocGroupStatus_PENDING", Swig_var_AllocGroupStatus_PENDING_get, Swig_var_AllocGroupStatus_PENDING_set);
  SWIG_addvarlink(globals, "AllocRequestStatus_ACCEPTED", Swig_var_AllocRequestStatus_ACCEPTED_get, Swig_var_AllocRequestStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "AllocRequestStatus_REJECTED", Swig_var_AllocRequestStatus_REJECTED_get, Swig_var_AllocRequestStatus_REJECTED_set);
  SWIG_addvarlink(globals, "MatchExceptionType_NO_MATCHING_CONFIRMATION", Swig_var_MatchExceptionType_NO_MATCHING_CONFIRMATION_get, Swig_var_MatchExceptionType_NO_MATCHING_CONFIRMATION_set);
  SWIG_addvarlink(globals, "MatchExceptionType_NO_MATCHING_ALLOCATION", Swig_var_MatchExceptionType_NO_MATCHING_ALLOCATION_get, Swig_var_MatchExceptionType_NO_MATCHING_ALLOCATION_set);
  SWIG_addvarlink(globals, "MatchExceptionType_ALLOCATION_DATA_ELEMENT_MISSING", Swig_var_MatchExceptionType_ALLOCATION_DATA_ELEMENT_MISSING_get, Swig_var_MatchExceptionType_ALLOCATION_DATA_ELEMENT_MISSING_set);
  SWIG_addvarlink(globals, "MatchExceptionType_CONFIRMATION_DATA_ELEMENT_MISSING", Swig_var_MatchExceptionType_CONFIRMATION_DATA_ELEMENT_MISSING_get, Swig_var_MatchExceptionType_CONFIRMATION_DATA_ELEMENT_MISSING_set);
  SWIG_addvarlink(globals, "MatchExceptionType_DATA_DIFFERENCE_NOT_WITHIN_TOLERANCE", Swig_var_MatchExceptionType_DATA_DIFFERENCE_NOT_WITHIN_TOLERANCE_get, Swig_var_MatchExceptionType_DATA_DIFFERENCE_NOT_WITHIN_TOLERANCE_set);
  SWIG_addvarlink(globals, "MatchExceptionType_MATCH_WITHIN_TOLERANCE", Swig_var_MatchExceptionType_MATCH_WITHIN_TOLERANCE_get, Swig_var_MatchExceptionType_MATCH_WITHIN_TOLERANCE_set);
  SWIG_addvarlink(globals, "MatchExceptionType_OTHER", Swig_var_MatchExceptionType_OTHER_get, Swig_var_MatchExceptionType_OTHER_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_ACCRUED_INTEREST", Swig_var_MatchExceptionElementType_ACCRUED_INTEREST_get, Swig_var_MatchExceptionElementType_ACCRUED_INTEREST_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_DEAL_PRICE", Swig_var_MatchExceptionElementType_DEAL_PRICE_get, Swig_var_MatchExceptionElementType_DEAL_PRICE_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_TRADE_DATE", Swig_var_MatchExceptionElementType_TRADE_DATE_get, Swig_var_MatchExceptionElementType_TRADE_DATE_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_SETTLEMENT_DATE", Swig_var_MatchExceptionElementType_SETTLEMENT_DATE_get, Swig_var_MatchExceptionElementType_SETTLEMENT_DATE_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_SIDE_INDICATOR", Swig_var_MatchExceptionElementType_SIDE_INDICATOR_get, Swig_var_MatchExceptionElementType_SIDE_INDICATOR_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_TRADED_CURRENCY", Swig_var_MatchExceptionElementType_TRADED_CURRENCY_get, Swig_var_MatchExceptionElementType_TRADED_CURRENCY_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_ACCOUNT_ID", Swig_var_MatchExceptionElementType_ACCOUNT_ID_get, Swig_var_MatchExceptionElementType_ACCOUNT_ID_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_EXECUTING_BROKER_ID", Swig_var_MatchExceptionElementType_EXECUTING_BROKER_ID_get, Swig_var_MatchExceptionElementType_EXECUTING_BROKER_ID_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_SETTLEMENT_CURRENCY_AND_AMOUNT", Swig_var_MatchExceptionElementType_SETTLEMENT_CURRENCY_AND_AMOUNT_get, Swig_var_MatchExceptionElementType_SETTLEMENT_CURRENCY_AND_AMOUNT_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_INVESTMENT_MANAGER_ID", Swig_var_MatchExceptionElementType_INVESTMENT_MANAGER_ID_get, Swig_var_MatchExceptionElementType_INVESTMENT_MANAGER_ID_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_NET_AMOUNT", Swig_var_MatchExceptionElementType_NET_AMOUNT_get, Swig_var_MatchExceptionElementType_NET_AMOUNT_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_PLACE_OF_SETTLEMENT", Swig_var_MatchExceptionElementType_PLACE_OF_SETTLEMENT_get, Swig_var_MatchExceptionElementType_PLACE_OF_SETTLEMENT_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_COMMISSIONS", Swig_var_MatchExceptionElementType_COMMISSIONS_get, Swig_var_MatchExceptionElementType_COMMISSIONS_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_SECURITY_IDENTIFIER", Swig_var_MatchExceptionElementType_SECURITY_IDENTIFIER_get, Swig_var_MatchExceptionElementType_SECURITY_IDENTIFIER_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_QUALITY_ALLOCATED", Swig_var_MatchExceptionElementType_QUALITY_ALLOCATED_get, Swig_var_MatchExceptionElementType_QUALITY_ALLOCATED_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_PRINCIPAL", Swig_var_MatchExceptionElementType_PRINCIPAL_get, Swig_var_MatchExceptionElementType_PRINCIPAL_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_FEES", Swig_var_MatchExceptionElementType_FEES_get, Swig_var_MatchExceptionElementType_FEES_set);
  SWIG_addvarlink(globals, "MatchExceptionElementType_TAX", Swig_var_MatchExceptionElementType_TAX_get, Swig_var_MatchExceptionElementType_TAX_set);
  SWIG_addvarlink(globals, "MatchExceptionToleranceValueType_FIXED_AMOUNT", Swig_var_MatchExceptionToleranceValueType_FIXED_AMOUNT_get, Swig_var_MatchExceptionToleranceValueType_FIXED_AMOUNT_set);
  SWIG_addvarlink(globals, "MatchExceptionToleranceValueType_PERCENTAGE", Swig_var_MatchExceptionToleranceValueType_PERCENTAGE_get, Swig_var_MatchExceptionToleranceValueType_PERCENTAGE_set);
  SWIG_addvarlink(globals, "MatchingDataPointIndicator_MANDATORY", Swig_var_MatchingDataPointIndicator_MANDATORY_get, Swig_var_MatchingDataPointIndicator_MANDATORY_set);
  SWIG_addvarlink(globals, "MatchingDataPointIndicator_OPTIONAL", Swig_var_MatchingDataPointIndicator_OPTIONAL_get, Swig_var_MatchingDataPointIndicator_OPTIONAL_set);
  SWIG_addvarlink(globals, "TradeAggregationTransType_NEW", Swig_var_TradeAggregationTransType_NEW_get, Swig_var_TradeAggregationTransType_NEW_set);
  SWIG_addvarlink(globals, "TradeAggregationTransType_CANCEL", Swig_var_TradeAggregationTransType_CANCEL_get, Swig_var_TradeAggregationTransType_CANCEL_set);
  SWIG_addvarlink(globals, "TradeAggregationTransType_REPLACE", Swig_var_TradeAggregationTransType_REPLACE_get, Swig_var_TradeAggregationTransType_REPLACE_set);
  SWIG_addvarlink(globals, "TradeAggregationRequestStatus_ACCEPTED", Swig_var_TradeAggregationRequestStatus_ACCEPTED_get, Swig_var_TradeAggregationRequestStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "TradeAggregationRequestStatus_REJECTED", Swig_var_TradeAggregationRequestStatus_REJECTED_get, Swig_var_TradeAggregationRequestStatus_REJECTED_set);
  SWIG_addvarlink(globals, "TradeAggregationRejectReason_UNKNOWN_ORDERS", Swig_var_TradeAggregationRejectReason_UNKNOWN_ORDERS_get, Swig_var_TradeAggregationRejectReason_UNKNOWN_ORDERS_set);
  SWIG_addvarlink(globals, "TradeAggregationRejectReason_UNKNOWN_EXECUTION_FILLS", Swig_var_TradeAggregationRejectReason_UNKNOWN_EXECUTION_FILLS_get, Swig_var_TradeAggregationRejectReason_UNKNOWN_EXECUTION_FILLS_set);
  SWIG_addvarlink(globals, "TradeAggregationRejectReason_OTHER", Swig_var_TradeAggregationRejectReason_OTHER_get, Swig_var_TradeAggregationRejectReason_OTHER_set);
  SWIG_addvarlink(globals, "OffshoreIndicator_REGULAR", Swig_var_OffshoreIndicator_REGULAR_get, Swig_var_OffshoreIndicator_REGULAR_set);
  SWIG_addvarlink(globals, "OffshoreIndicator_OFFSHORE", Swig_var_OffshoreIndicator_OFFSHORE_get, Swig_var_OffshoreIndicator_OFFSHORE_set);
  SWIG_addvarlink(globals, "OffshoreIndicator_ONSHORE", Swig_var_OffshoreIndicator_ONSHORE_get, Swig_var_OffshoreIndicator_ONSHORE_set);
  SWIG_addvarlink(globals, "PayReportTransType_NEW", Swig_var_PayReportTransType_NEW_get, Swig_var_PayReportTransType_NEW_set);
  SWIG_addvarlink(globals, "PayReportTransType_REPLACE", Swig_var_PayReportTransType_REPLACE_get, Swig_var_PayReportTransType_REPLACE_set);
  SWIG_addvarlink(globals, "PayReportTransType_STATUS", Swig_var_PayReportTransType_STATUS_get, Swig_var_PayReportTransType_STATUS_set);
  SWIG_addvarlink(globals, "PayReportStatus_RECEIVED", Swig_var_PayReportStatus_RECEIVED_get, Swig_var_PayReportStatus_RECEIVED_set);
  SWIG_addvarlink(globals, "PayReportStatus_ACCEPTED", Swig_var_PayReportStatus_ACCEPTED_get, Swig_var_PayReportStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "PayReportStatus_REJECTED", Swig_var_PayReportStatus_REJECTED_get, Swig_var_PayReportStatus_REJECTED_set);
  SWIG_addvarlink(globals, "PayReportStatus_DISPUTED", Swig_var_PayReportStatus_DISPUTED_get, Swig_var_PayReportStatus_DISPUTED_set);
  SWIG_addvarlink(globals, "PayRequestTransType_NEW", Swig_var_PayRequestTransType_NEW_get, Swig_var_PayRequestTransType_NEW_set);
  SWIG_addvarlink(globals, "PayRequestTransType_CANCEL", Swig_var_PayRequestTransType_CANCEL_get, Swig_var_PayRequestTransType_CANCEL_set);
  SWIG_addvarlink(globals, "PayRequestStatus_RECEIVED", Swig_var_PayRequestStatus_RECEIVED_get, Swig_var_PayRequestStatus_RECEIVED_set);
  SWIG_addvarlink(globals, "PayRequestStatus_ACCEPTED", Swig_var_PayRequestStatus_ACCEPTED_get, Swig_var_PayRequestStatus_ACCEPTED_set);
  SWIG_addvarlink(globals, "PayRequestStatus_REJECTED", Swig_var_PayRequestStatus_REJECTED_get, Swig_var_PayRequestStatus_REJECTED_set);
  SWIG_addvarlink(globals, "PayRequestStatus_DISPUTED", Swig_var_PayRequestStatus_DISPUTED_get, Swig_var_PayRequestStatus_DISPUTED_set);
  SWIG_addvarlink(globals, "PostTradePaymentDebitOrCredit_DEBIT_PAY", Swig_var_PostTradePaymentDebitOrCredit_DEBIT_PAY_get, Swig_var_PostTradePaymentDebitOrCredit_DEBIT_PAY_set);
  SWIG_addvarlink(globals, "PostTradePaymentDebitOrCredit_CREDIT_RECEIVE", Swig_var_PostTradePaymentDebitOrCredit_CREDIT_RECEIVE_get, Swig_var_PostTradePaymentDebitOrCredit_CREDIT_RECEIVE_set);
  SWIG_addvarlink(globals, "PostTradePaymentStatus_NEW", Swig_var_PostTradePaymentStatus_NEW_get, Swig_var_PostTradePaymentStatus_NEW_set);
  SWIG_addvarlink(globals, "PostTradePaymentStatus_INITIATED", Swig_var_PostTradePaymentStatus_INITIATED_get, Swig_var_PostTradePaymentStatus_INITIATED_set);
  SWIG_addvarlink(globals, "PostTradePaymentStatus_PENDING", Swig_var_PostTradePaymentStatus_PENDING_get, Swig_var_PostTradePaymentStatus_PENDING_set);
  SWIG_addvarlink(globals, "PostTradePaymentStatus_CONFIRMED", Swig_var_PostTradePaymentStatus_CONFIRMED_get, Swig_var_PostTradePaymentStatus_CONFIRMED_set);
  SWIG_addvarlink(globals, "PostTradePaymentStatus_REJECTED", Swig_var_PostTradePaymentStatus_REJECTED_get, Swig_var_PostTradePaymentStatus_REJECTED_set);
  SWIG_addvarlink(globals, "DuplicateClOrdIDIndicator_NO", Swig_var_DuplicateClOrdIDIndicator_NO_get, Swig_var_DuplicateClOrdIDIndicator_NO_set);
  SWIG_addvarlink(globals, "DuplicateClOrdIDIndicator_YES", Swig_var_DuplicateClOrdIDIndicator_YES_get, Swig_var_DuplicateClOrdIDIndicator_YES_set);
  SWIG_addvarlink(globals, "EventInitiatorType_CUSTOMER_OR_CLIENT", Swig_var_EventInitiatorType_CUSTOMER_OR_CLIENT_get, Swig_var_EventInitiatorType_CUSTOMER_OR_CLIENT_set);
  SWIG_addvarlink(globals, "EventInitiatorType_EXCHANGE_OR_EXECUTION_VENUE", Swig_var_EventInitiatorType_EXCHANGE_OR_EXECUTION_VENUE_get, Swig_var_EventInitiatorType_EXCHANGE_OR_EXECUTION_VENUE_set);
  SWIG_addvarlink(globals, "EventInitiatorType_FIRM_OR_BROKER", Swig_var_EventInitiatorType_FIRM_OR_BROKER_get, Swig_var_EventInitiatorType_FIRM_OR_BROKER_set);
  SWIG_addvarlink(globals, "NBBOEntryType_BID", Swig_var_NBBOEntryType_BID_get, Swig_var_NBBOEntryType_BID_set);
  SWIG_addvarlink(globals, "NBBOEntryType_OFFER", Swig_var_NBBOEntryType_OFFER_get, Swig_var_NBBOEntryType_OFFER_set);
  SWIG_addvarlink(globals, "NBBOEntryType_MID_PRICE", Swig_var_NBBOEntryType_MID_PRICE_get, Swig_var_NBBOEntryType_MID_PRICE_set);
  SWIG_addvarlink(globals, "NBBOSource_NOT_APPLICABLE", Swig_var_NBBOSource_NOT_APPLICABLE_get, Swig_var_NBBOSource_NOT_APPLICABLE_set);
  SWIG_addvarlink(globals, "NBBOSource_DIRECT", Swig_var_NBBOSource_DIRECT_get, Swig_var_NBBOSource_DIRECT_set);
  SWIG_addvarlink(globals, "NBBOSource_SIP", Swig_var_NBBOSource_SIP_get, Swig_var_NBBOSource_SIP_set);
  SWIG_addvarlink(globals, "NBBOSource_HYBRID", Swig_var_NBBOSource_HYBRID_get, Swig_var_NBBOSource_HYBRID_set);
  SWIG_addvarlink(globals, "SingleQuoteIndicator_NO", Swig_var_SingleQuoteIndicator_NO_get, Swig_var_SingleQuoteIndicator_NO_set);
  SWIG_addvarlink(globals, "SingleQuoteIndicator_YES", Swig_var_SingleQuoteIndicator_YES_get, Swig_var_SingleQuoteIndicator_YES_set);
  SWIG_addvarlink(globals, "TrdRegTimestampManualIndicator_NO", Swig_var_TrdRegTimestampManualIndicator_NO_get, Swig_var_TrdRegTimestampManualIndicator_NO_set);
  SWIG_addvarlink(globals, "TrdRegTimestampManualIndicator_YES", Swig_var_TrdRegTimestampManualIndicator_YES_get, Swig_var_TrdRegTimestampManualIndicator_YES_set);
  SWIG_addvarlink(globals, "CollateralReinvestmentType_MONEY_MARKET_FUND", Swig_var_CollateralReinvestmentType_MONEY_MARKET_FUND_get, Swig_var_CollateralReinvestmentType_MONEY_MARKET_FUND_set);
  SWIG_addvarlink(globals, "CollateralReinvestmentType_OTHER_COMINGLED_POOL", Swig_var_CollateralReinvestmentType_OTHER_COMINGLED_POOL_get, Swig_var_CollateralReinvestmentType_OTHER_COMINGLED_POOL_set);
  SWIG_addvarlink(globals, "CollateralReinvestmentType_REPO_MARKET", Swig_var_CollateralReinvestmentType_REPO_MARKET_get, Swig_var_CollateralReinvestmentType_REPO_MARKET_set);
  SWIG_addvarlink(globals, "CollateralReinvestmentType_DIRECT_PURCHASE_OF_SECURITIES", Swig_var_CollateralReinvestmentType_DIRECT_PURCHASE_OF_SECURITIES_get, Swig_var_CollateralReinvestmentType_DIRECT_PURCHASE_OF_SECURITIES_set);
  SWIG_addvarlink(globals, "CollateralReinvestmentType_OTHER_INVESTMENTS", Swig_var_CollateralReinvestmentType_OTHER_INVESTMENTS_get, Swig_var_CollateralReinvestmentType_OTHER_INVESTMENTS_set);
  SWIG_addvarlink(globals, "FundingSource_REPO", Swig_var_FundingSource_REPO_get, Swig_var_FundingSource_REPO_set);
  SWIG_addvarlink(globals, "FundingSource_CASH", Swig_var_FundingSource_CASH_get, Swig_var_FundingSource_CASH_set);
  SWIG_addvarlink(globals, "FundingSource_FREE_CEDITS", Swig_var_FundingSource_FREE_CEDITS_get, Swig_var_FundingSource_FREE_CEDITS_set);
  SWIG_addvarlink(globals, "FundingSource_CUSTOMER_SHORT_SALES", Swig_var_FundingSource_CUSTOMER_SHORT_SALES_get, Swig_var_FundingSource_CUSTOMER_SHORT_SALES_set);
  SWIG_addvarlink(globals, "FundingSource_BROKER_SHORT_SALES", Swig_var_FundingSource_BROKER_SHORT_SALES_get, Swig_var_FundingSource_BROKER_SHORT_SALES_set);
  SWIG_addvarlink(globals, "FundingSource_UNSECURED_BORROWING", Swig_var_FundingSource_UNSECURED_BORROWING_get, Swig_var_FundingSource_UNSECURED_BORROWING_set);
  SWIG_addvarlink(globals, "FundingSource_OTHER", Swig_var_FundingSource_OTHER_get, Swig_var_FundingSource_OTHER_set);
  SWIG_addvarlink(globals, "MarginDirection_POSTED", Swig_var_MarginDirection_POSTED_get, Swig_var_MarginDirection_POSTED_set);
  SWIG_addvarlink(globals, "MarginDirection_RECEIVED", Swig_var_MarginDirection_RECEIVED_get, Swig_var_MarginDirection_RECEIVED_set);
  SWIG_addvarlink(globals, "TransactionAttributeType_EXCLUSIVE_ARRANGEMENT", Swig_var_TransactionAttributeType_EXCLUSIVE_ARRANGEMENT_get, Swig_var_TransactionAttributeType_EXCLUSIVE_ARRANGEMENT_set);
  SWIG_addvarlink(globals, "TransactionAttributeType_COLLATERAL_REUSE", Swig_var_TransactionAttributeType_COLLATERAL_REUSE_get, Swig_var_TransactionAttributeType_COLLATERAL_REUSE_set);
  SWIG_addvarlink(globals, "TransactionAttributeType_COLLATERAL_ARRANGMENT_TYPE", Swig_var_TransactionAttributeType_COLLATERAL_ARRANGMENT_TYPE_get, Swig_var_TransactionAttributeType_COLLATERAL_ARRANGMENT_TYPE_set);
  SWIG_addvarlink(globals, "RoutingArrangmentIndicator_NO_ROUTING_ARRANGMENT_IN_PLACE", Swig_var_RoutingArrangmentIndicator_NO_ROUTING_ARRANGMENT_IN_PLACE_get, Swig_var_RoutingArrangmentIndicator_NO_ROUTING_ARRANGMENT_IN_PLACE_set);
  SWIG_addvarlink(globals, "RoutingArrangmentIndicator_ROUTING_ARRANGEMENT_IN_PLACE", Swig_var_RoutingArrangmentIndicator_ROUTING_ARRANGEMENT_IN_PLACE_get, Swig_var_RoutingArrangmentIndicator_ROUTING_ARRANGEMENT_IN_PLACE_set);
  SWIG_addvarlink(globals, "RelatedOrderIDSource_NON_FIX_SOURCE", Swig_var_RelatedOrderIDSource_NON_FIX_SOURCE_get, Swig_var_RelatedOrderIDSource_NON_FIX_SOURCE_set);
  SWIG_addvarlink(globals, "RelatedOrderIDSource_SYSTEM_ORDER_IDENTIFIER", Swig_var_RelatedOrderIDSource_SYSTEM_ORDER_IDENTIFIER_get, Swig_var_RelatedOrderIDSource_SYSTEM_ORDER_IDENTIFIER_set);
  SWIG_addvarlink(globals, "RelatedOrderIDSource_CLIENT_ORDER_IDENTIFIER", Swig_var_RelatedOrderIDSource_CLIENT_ORDER_IDENTIFIER_get, Swig_var_RelatedOrderIDSource_CLIENT_ORDER_IDENTIFIER_set);
  SWIG_addvarlink(globals, "RelatedOrderIDSource_SECONDARY_ORDER_IDENTIFIER", Swig_var_RelatedOrderIDSource_SECONDARY_ORDER_IDENTIFIER_get, Swig_var_RelatedOrderIDSource_SECONDARY_ORDER_IDENTIFIER_set);
  SWIG_addvarlink(globals, "RelatedOrderIDSource_SECONDARY_CLIENT_ORDER_IDENTIFIER", Swig_var_RelatedOrderIDSource_SECONDARY_CLIENT_ORDER_IDENTIFIER_get, Swig_var_RelatedOrderIDSource_SECONDARY_CLIENT_ORDER_IDENTIFIER_set);
  SWIG_addvarlink(globals, "OrderRelationship_NOT_SPECIFIED", Swig_var_OrderRelationship_NOT_SPECIFIED_get, Swig_var_OrderRelationship_NOT_SPECIFIED_set);
  SWIG_addvarlink(globals, "OrderRelationship_ORDER_AGGREGATION", Swig_var_OrderRelationship_ORDER_AGGREGATION_get, Swig_var_OrderRelationship_ORDER_AGGREGATION_set);
  SWIG_addvarlink(globals, "OrderRelationship_ORDER_SPLIT", Swig_var_OrderRelationship_ORDER_SPLIT_get, Swig_var_OrderRelationship_ORDER_SPLIT_set);
  SWIG_addvarlink(globals, "CurrencyCodeSource_CUSIP", Swig_var_CurrencyCodeSource_CUSIP_get, Swig_var_CurrencyCodeSource_CUSIP_set);
  SWIG_addvarlink(globals, "CurrencyCodeSource_SEDOL", Swig_var_CurrencyCodeSource_SEDOL_get, Swig_var_CurrencyCodeSource_SEDOL_set);
  SWIG_addvarlink(globals, "CurrencyCodeSource_ISIN_NUMBER", Swig_var_CurrencyCodeSource_ISIN_NUMBER_get, Swig_var_CurrencyCodeSource_ISIN_NUMBER_set);
  SWIG_addvarlink(globals, "CurrencyCodeSource_ISO_CURRENCY_CODE", Swig_var_CurrencyCodeSource_ISO_CURRENCY_CODE_get, Swig_var_CurrencyCodeSource_ISO_CURRENCY_CODE_set);
  SWIG_addvarlink(globals, "CurrencyCodeSource_FINANCIAL_INSTRUMENT_GLOBAL_IDENTIFIER", Swig_var_CurrencyCodeSource_FINANCIAL_INSTRUMENT_GLOBAL_IDENTIFIER_get, Swig_var_CurrencyCodeSource_FINANCIAL_INSTRUMENT_GLOBAL_IDENTIFIER_set);
  SWIG_addvarlink(globals, "CurrencyCodeSource_DIGITAL_TOKEN_IDENTIFIER", Swig_var_CurrencyCodeSource_DIGITAL_TOKEN_IDENTIFIER_get, Swig_var_CurrencyCodeSource_DIGITAL_TOKEN_IDENTIFIER_set);
  SWIG_addvarlink(globals, "MultiJurisdictionReportingIndicator_NOT_MULTI_JRSDCTN_ELIGIBLE", Swig_var_MultiJurisdictionReportingIndicator_NOT_MULTI_JRSDCTN_ELIGIBLE_get, Swig_var_MultiJurisdictionReportingIndicator_NOT_MULTI_JRSDCTN_ELIGIBLE_set);
  SWIG_addvarlink(globals, "MultiJurisdictionReportingIndicator_MULTI_JRSDCTN_ELIGIBLE", Swig_var_MultiJurisdictionReportingIndicator_MULTI_JRSDCTN_ELIGIBLE_get, Swig_var_MultiJurisdictionReportingIndicator_MULTI_JRSDCTN_ELIGIBLE_set);
  SWIG_addvarlink(globals, "SelfMatchPreventionInstruction_CANCEL_AGGRESSIVE", Swig_var_SelfMatchPreventionInstruction_CANCEL_AGGRESSIVE_get, Swig_var_SelfMatchPreventionInstruction_CANCEL_AGGRESSIVE_set);
  SWIG_addvarlink(globals, "SelfMatchPreventionInstruction_CANCEL_PASSIVE", Swig_var_SelfMatchPreventionInstruction_CANCEL_PASSIVE_get, Swig_var_SelfMatchPreventionInstruction_CANCEL_PASSIVE_set);
  SWIG_addvarlink(globals, "SelfMatchPreventionInstruction_CANCEL_AGGRESSIVE_PASSIVE", Swig_var_SelfMatchPreventionInstruction_CANCEL_AGGRESSIVE_PASSIVE_get, Swig_var_SelfMatchPreventionInstruction_CANCEL_AGGRESSIVE_PASSIVE_set);
  SWIG_addvarlink(globals, "BEGINSTRING", Swig_var_BEGINSTRING_get, Swig_var_BEGINSTRING_set);
  SWIG_addvarlink(globals, "SENDERCOMPID", Swig_var_SENDERCOMPID_get, Swig_var_SENDERCOMPID_set);
  SWIG_addvarlink(globals, "TARGETCOMPID", Swig_var_TARGETCOMPID_get, Swig_var_TARGETCOMPID_set);
  SWIG_addvarlink(globals, "SESSION_QUALIFIER", Swig_var_SESSION_QUALIFIER_get, Swig_var_SESSION_QUALIFIER_set);
  SWIG_addvarlink(globals, "DEFAULT_APPLVERID", Swig_var_DEFAULT_APPLVERID_get, Swig_var_DEFAULT_APPLVERID_set);
  SWIG_addvarlink(globals, "CONNECTION_TYPE", Swig_var_CONNECTION_TYPE_get, Swig_var_CONNECTION_TYPE_set);
  SWIG_addvarlink(globals, "USE_DATA_DICTIONARY", Swig_var_USE_DATA_DICTIONARY_get, Swig_var_USE_DATA_DICTIONARY_set);
  SWIG_addvarlink(globals, "SEND_RESETSEQNUMFLAG", Swig_var_SEND_RESETSEQNUMFLAG_get, Swig_var_SEND_RESETSEQNUMFLAG_set);
  SWIG_addvarlink(globals, "SEND_REDUNDANT_RESENDREQUESTS", Swig_var_SEND_REDUNDANT_RESENDREQUESTS_get, Swig_var_SEND_REDUNDANT_RESENDREQUESTS_set);
  SWIG_addvarlink(globals, "SEND_NEXT_EXPECTED_MSG_SEQ_NUM", Swig_var_SEND_NEXT_EXPECTED_MSG_SEQ_NUM_get, Swig_var_SEND_NEXT_EXPECTED_MSG_SEQ_NUM_set);
  SWIG_addvarlink(globals, "DATA_DICTIONARY", Swig_var_DATA_DICTIONARY_get, Swig_var_DATA_DICTIONARY_set);
  SWIG_addvarlink(globals, "TRANSPORT_DATA_DICTIONARY", Swig_var_TRANSPORT_DATA_DICTIONARY_get, Swig_var_TRANSPORT_DATA_DICTIONARY_set);
  SWIG_addvarlink(globals, "APP_DATA_DICTIONARY", Swig_var_APP_DATA_DICTIONARY_get, Swig_var_APP_DATA_DICTIONARY_set);
  SWIG_addvarlink(globals, "USE_LOCAL_TIME", Swig_var_USE_LOCAL_TIME_get, Swig_var_USE_LOCAL_TIME_set);
  SWIG_addvarlink(globals, "START_TIME", Swig_var_START_TIME_get, Swig_var_START_TIME_set);
  SWIG_addvarlink(globals, "END_TIME", Swig_var_END_TIME_get, Swig_var_END_TIME_set);
  SWIG_addvarlink(globals, "START_DAY", Swig_var_START_DAY_get, Swig_var_START_DAY_set);
  SWIG_addvarlink(globals, "END_DAY", Swig_var_END_DAY_get, Swig_var_END_DAY_set);
  SWIG_addvarlink(globals, "NON_STOP_SESSION", Swig_var_NON_STOP_SESSION_get, Swig_var_NON_STOP_SESSION_set);
  SWIG_addvarlink(globals, "LOGON_TIME", Swig_var_LOGON_TIME_get, Swig_var_LOGON_TIME_set);
  SWIG_addvarlink(globals, "LOGOUT_TIME", Swig_var_LOGOUT_TIME_get, Swig_var_LOGOUT_TIME_set);
  SWIG_addvarlink(globals, "LOGON_DAY", Swig_var_LOGON_DAY_get, Swig_var_LOGON_DAY_set);
  SWIG_addvarlink(globals, "LOGOUT_DAY", Swig_var_LOGOUT_DAY_get, Swig_var_LOGOUT_DAY_set);
  SWIG_addvarlink(globals, "CHECK_COMPID", Swig_var_CHECK_COMPID_get, Swig_var_CHECK_COMPID_set);
  SWIG_addvarlink(globals, "CHECK_LATENCY", Swig_var_CHECK_LATENCY_get, Swig_var_CHECK_LATENCY_set);
  SWIG_addvarlink(globals, "MAX_LATENCY", Swig_var_MAX_LATENCY_get, Swig_var_MAX_LATENCY_set);
  SWIG_addvarlink(globals, "HEARTBTINT", Swig_var_HEARTBTINT_get, Swig_var_HEARTBTINT_set);
  SWIG_addvarlink(globals, "SOCKET_ACCEPT_PORT", Swig_var_SOCKET_ACCEPT_PORT_get, Swig_var_SOCKET_ACCEPT_PORT_set);
  SWIG_addvarlink(globals, "SOCKET_REUSE_ADDRESS", Swig_var_SOCKET_REUSE_ADDRESS_get, Swig_var_SOCKET_REUSE_ADDRESS_set);
  SWIG_addvarlink(globals, "SOCKET_CONNECT_HOST", Swig_var_SOCKET_CONNECT_HOST_get, Swig_var_SOCKET_CONNECT_HOST_set);
  SWIG_addvarlink(globals, "SOCKET_CONNECT_PORT", Swig_var_SOCKET_CONNECT_PORT_get, Swig_var_SOCKET_CONNECT_PORT_set);
  SWIG_addvarlink(globals, "SOCKET_CONNECT_SOURCE_HOST", Swig_var_SOCKET_CONNECT_SOURCE_HOST_get, Swig_var_SOCKET_CONNECT_SOURCE_HOST_set);
  SWIG_addvarlink(globals, "SOCKET_CONNECT_SOURCE_PORT", Swig_var_SOCKET_CONNECT_SOURCE_PORT_get, Swig_var_SOCKET_CONNECT_SOURCE_PORT_set);
  SWIG_addvarlink(globals, "SOCKET_NODELAY", Swig_var_SOCKET_NODELAY_get, Swig_var_SOCKET_NODELAY_set);
  SWIG_addvarlink(globals, "SOCKET_SEND_BUFFER_SIZE", Swig_var_SOCKET_SEND_BUFFER_SIZE_get, Swig_var_SOCKET_SEND_BUFFER_SIZE_set);
  SWIG_addvarlink(globals, "SOCKET_RECEIVE_BUFFER_SIZE", Swig_var_SOCKET_RECEIVE_BUFFER_SIZE_get, Swig_var_SOCKET_RECEIVE_BUFFER_SIZE_set);
  SWIG_addvarlink(globals, "HOST_SELECTION_POLICY", Swig_var_HOST_SELECTION_POLICY_get, Swig_var_HOST_SELECTION_POLICY_set);
  SWIG_addvarlink(globals, "HOST_SELECTION_POLICY_PRIORITY_START_OVER_INTERVAL", Swig_var_HOST_SELECTION_POLICY_PRIORITY_START_OVER_INTERVAL_get, Swig_var_HOST_SELECTION_POLICY_PRIORITY_START_OVER_INTERVAL_set);
  SWIG_addvarlink(globals, "RECONNECT_INTERVAL", Swig_var_RECONNECT_INTERVAL_get, Swig_var_RECONNECT_INTERVAL_set);
  SWIG_addvarlink(globals, "VALIDATE_LENGTH_AND_CHECKSUM", Swig_var_VALIDATE_LENGTH_AND_CHECKSUM_get, Swig_var_VALIDATE_LENGTH_AND_CHECKSUM_set);
  SWIG_addvarlink(globals, "VALIDATE_FIELDS_OUT_OF_ORDER", Swig_var_VALIDATE_FIELDS_OUT_OF_ORDER_get, Swig_var_VALIDATE_FIELDS_OUT_OF_ORDER_set);
  SWIG_addvarlink(globals, "VALIDATE_FIELDS_HAVE_VALUES", Swig_var_VALIDATE_FIELDS_HAVE_VALUES_get, Swig_var_VALIDATE_FIELDS_HAVE_VALUES_set);
  SWIG_addvarlink(globals, "VALIDATE_USER_DEFINED_FIELDS", Swig_var_VALIDATE_USER_DEFINED_FIELDS_get, Swig_var_VALIDATE_USER_DEFINED_FIELDS_set);
  SWIG_addvarlink(globals, "ALLOW_UNKNOWN_MSG_FIELDS", Swig_var_ALLOW_UNKNOWN_MSG_FIELDS_get, Swig_var_ALLOW_UNKNOWN_MSG_FIELDS_set);
  SWIG_addvarlink(globals, "PRESERVE_MESSAGE_FIELDS_ORDER", Swig_var_PRESERVE_MESSAGE_FIELDS_ORDER_get, Swig_var_PRESERVE_MESSAGE_FIELDS_ORDER_set);
  SWIG_addvarlink(globals, "LOGON_TIMEOUT", Swig_var_LOGON_TIMEOUT_get, Swig_var_LOGON_TIMEOUT_set);
  SWIG_addvarlink(globals, "LOGOUT_TIMEOUT", Swig_var_LOGOUT_TIMEOUT_get, Swig_var_LOGOUT_TIMEOUT_set);
  SWIG_addvarlink(globals, "FILE_STORE_PATH", Swig_var_FILE_STORE_PATH_get, Swig_var_FILE_STORE_PATH_set);
  SWIG_addvarlink(globals, "MYSQL_STORE_USECONNECTIONPOOL", Swig_var_MYSQL_STORE_USECONNECTIONPOOL_get, Swig_var_MYSQL_STORE_USECONNECTIONPOOL_set);
  SWIG_addvarlink(globals, "MYSQL_STORE_DATABASE", Swig_var_MYSQL_STORE_DATABASE_get, Swig_var_MYSQL_STORE_DATABASE_set);
  SWIG_addvarlink(globals, "MYSQL_STORE_USER", Swig_var_MYSQL_STORE_USER_get, Swig_var_MYSQL_STORE_USER_set);
  SWIG_addvarlink(globals, "MYSQL_STORE_PASSWORD", Swig_var_MYSQL_STORE_PASSWORD_get, Swig_var_MYSQL_STORE_PASSWORD_set);
  SWIG_addvarlink(globals, "MYSQL_STORE_HOST", Swig_var_MYSQL_STORE_HOST_get, Swig_var_MYSQL_STORE_HOST_set);
  SWIG_addvarlink(globals, "MYSQL_STORE_PORT", Swig_var_MYSQL_STORE_PORT_get, Swig_var_MYSQL_STORE_PORT_set);
  SWIG_addvarlink(globals, "POSTGRESQL_STORE_USECONNECTIONPOOL", Swig_var_POSTGRESQL_STORE_USECONNECTIONPOOL_get, Swig_var_POSTGRESQL_STORE_USECONNECTIONPOOL_set);
  SWIG_addvarlink(globals, "POSTGRESQL_STORE_DATABASE", Swig_var_POSTGRESQL_STORE_DATABASE_get, Swig_var_POSTGRESQL_STORE_DATABASE_set);
  SWIG_addvarlink(globals, "POSTGRESQL_STORE_USER", Swig_var_POSTGRESQL_STORE_USER_get, Swig_var_POSTGRESQL_STORE_USER_set);
  SWIG_addvarlink(globals, "POSTGRESQL_STORE_PASSWORD", Swig_var_POSTGRESQL_STORE_PASSWORD_get, Swig_var_POSTGRESQL_STORE_PASSWORD_set);
  SWIG_addvarlink(globals, "POSTGRESQL_STORE_HOST", Swig_var_POSTGRESQL_STORE_HOST_get, Swig_var_POSTGRESQL_STORE_HOST_set);
  SWIG_addvarlink(globals, "POSTGRESQL_STORE_PORT", Swig_var_POSTGRESQL_STORE_PORT_get, Swig_var_POSTGRESQL_STORE_PORT_set);
  SWIG_addvarlink(globals, "ODBC_STORE_USER", Swig_var_ODBC_STORE_USER_get, Swig_var_ODBC_STORE_USER_set);
  SWIG_addvarlink(globals, "ODBC_STORE_PASSWORD", Swig_var_ODBC_STORE_PASSWORD_get, Swig_var_ODBC_STORE_PASSWORD_set);
  SWIG_addvarlink(globals, "ODBC_STORE_CONNECTION_STRING", Swig_var_ODBC_STORE_CONNECTION_STRING_get, Swig_var_ODBC_STORE_CONNECTION_STRING_set);
  SWIG_addvarlink(globals, "FILE_LOG_PATH", Swig_var_FILE_LOG_PATH_get, Swig_var_FILE_LOG_PATH_set);
  SWIG_addvarlink(globals, "FILE_LOG_BACKUP_PATH", Swig_var_FILE_LOG_BACKUP_PATH_get, Swig_var_FILE_LOG_BACKUP_PATH_set);
  SWIG_addvarlink(globals, "SCREEN_LOG_SHOW_INCOMING", Swig_var_SCREEN_LOG_SHOW_INCOMING_get, Swig_var_SCREEN_LOG_SHOW_INCOMING_set);
  SWIG_addvarlink(globals, "SCREEN_LOG_SHOW_OUTGOING", Swig_var_SCREEN_LOG_SHOW_OUTGOING_get, Swig_var_SCREEN_LOG_SHOW_OUTGOING_set);
  SWIG_addvarlink(globals, "SCREEN_LOG_SHOW_EVENTS", Swig_var_SCREEN_LOG_SHOW_EVENTS_get, Swig_var_SCREEN_LOG_SHOW_EVENTS_set);
  SWIG_addvarlink(globals, "MYSQL_LOG_USECONNECTIONPOOL", Swig_var_MYSQL_LOG_USECONNECTIONPOOL_get, Swig_var_MYSQL_LOG_USECONNECTIONPOOL_set);
  SWIG_addvarlink(globals, "MYSQL_LOG_DATABASE", Swig_var_MYSQL_LOG_DATABASE_get, Swig_var_MYSQL_LOG_DATABASE_set);
  SWIG_addvarlink(globals, "MYSQL_LOG_USER", Swig_var_MYSQL_LOG_USER_get, Swig_var_MYSQL_LOG_USER_set);
  SWIG_addvarlink(globals, "MYSQL_LOG_PASSWORD", Swig_var_MYSQL_LOG_PASSWORD_get, Swig_var_MYSQL_LOG_PASSWORD_set);
  SWIG_addvarlink(globals, "MYSQL_LOG_HOST", Swig_var_MYSQL_LOG_HOST_get, Swig_var_MYSQL_LOG_HOST_set);
  SWIG_addvarlink(globals, "MYSQL_LOG_PORT", Swig_var_MYSQL_LOG_PORT_get, Swig_var_MYSQL_LOG_PORT_set);
  SWIG_addvarlink(globals, "MYSQL_LOG_INCOMING_TABLE", Swig_var_MYSQL_LOG_INCOMING_TABLE_get, Swig_var_MYSQL_LOG_INCOMING_TABLE_set);
  SWIG_addvarlink(globals, "MYSQL_LOG_OUTGOING_TABLE", Swig_var_MYSQL_LOG_OUTGOING_TABLE_get, Swig_var_MYSQL_LOG_OUTGOING_TABLE_set);
  SWIG_addvarlink(globals, "MYSQL_LOG_EVENT_TABLE", Swig_var_MYSQL_LOG_EVENT_TABLE_get, Swig_var_MYSQL_LOG_EVENT_TABLE_set);
  SWIG_addvarlink(globals, "POSTGRESQL_LOG_USECONNECTIONPOOL", Swig_var_POSTGRESQL_LOG_USECONNECTIONPOOL_get, Swig_var_POSTGRESQL_LOG_USECONNECTIONPOOL_set);
  SWIG_addvarlink(globals, "POSTGRESQL_LOG_DATABASE", Swig_var_POSTGRESQL_LOG_DATABASE_get, Swig_var_POSTGRESQL_LOG_DATABASE_set);
  SWIG_addvarlink(globals, "POSTGRESQL_LOG_USER", Swig_var_POSTGRESQL_LOG_USER_get, Swig_var_POSTGRESQL_LOG_USER_set);
  SWIG_addvarlink(globals, "POSTGRESQL_LOG_PASSWORD", Swig_var_POSTGRESQL_LOG_PASSWORD_get, Swig_var_POSTGRESQL_LOG_PASSWORD_set);
  SWIG_addvarlink(globals, "POSTGRESQL_LOG_HOST", Swig_var_POSTGRESQL_LOG_HOST_get, Swig_var_POSTGRESQL_LOG_HOST_set);
  SWIG_addvarlink(globals, "POSTGRESQL_LOG_PORT", Swig_var_POSTGRESQL_LOG_PORT_get, Swig_var_POSTGRESQL_LOG_PORT_set);
  SWIG_addvarlink(globals, "POSTGRESQL_LOG_INCOMING_TABLE", Swig_var_POSTGRESQL_LOG_INCOMING_TABLE_get, Swig_var_POSTGRESQL_LOG_INCOMING_TABLE_set);
  SWIG_addvarlink(globals, "POSTGRESQL_LOG_OUTGOING_TABLE", Swig_var_POSTGRESQL_LOG_OUTGOING_TABLE_get, Swig_var_POSTGRESQL_LOG_OUTGOING_TABLE_set);
  SWIG_addvarlink(globals, "POSTGRESQL_LOG_EVENT_TABLE", Swig_var_POSTGRESQL_LOG_EVENT_TABLE_get, Swig_var_POSTGRESQL_LOG_EVENT_TABLE_set);
  SWIG_addvarlink(globals, "ODBC_LOG_USER", Swig_var_ODBC_LOG_USER_get, Swig_var_ODBC_LOG_USER_set);
  SWIG_addvarlink(globals, "ODBC_LOG_PASSWORD", Swig_var_ODBC_LOG_PASSWORD_get, Swig_var_ODBC_LOG_PASSWORD_set);
  SWIG_addvarlink(globals, "ODBC_LOG_CONNECTION_STRING", Swig_var_ODBC_LOG_CONNECTION_STRING_get, Swig_var_ODBC_LOG_CONNECTION_STRING_set);
  SWIG_addvarlink(globals, "ODBC_LOG_INCOMING_TABLE", Swig_var_ODBC_LOG_INCOMING_TABLE_get, Swig_var_ODBC_LOG_INCOMING_TABLE_set);
  SWIG_addvarlink(globals, "ODBC_LOG_OUTGOING_TABLE", Swig_var_ODBC_LOG_OUTGOING_TABLE_get, Swig_var_ODBC_LOG_OUTGOING_TABLE_set);
  SWIG_addvarlink(globals, "ODBC_LOG_EVENT_TABLE", Swig_var_ODBC_LOG_EVENT_TABLE_get, Swig_var_ODBC_LOG_EVENT_TABLE_set);
  SWIG_addvarlink(globals, "RESET_ON_LOGON", Swig_var_RESET_ON_LOGON_get, Swig_var_RESET_ON_LOGON_set);
  SWIG_addvarlink(globals, "RESET_ON_LOGOUT", Swig_var_RESET_ON_LOGOUT_get, Swig_var_RESET_ON_LOGOUT_set);
  SWIG_addvarlink(globals, "RESET_ON_DISCONNECT", Swig_var_RESET_ON_DISCONNECT_get, Swig_var_RESET_ON_DISCONNECT_set);
  SWIG_addvarlink(globals, "REFRESH_ON_LOGON", Swig_var_REFRESH_ON_LOGON_get, Swig_var_REFRESH_ON_LOGON_set);
  SWIG_addvarlink(globals, "MILLISECONDS_IN_TIMESTAMP", Swig_var_MILLISECONDS_IN_TIMESTAMP_get, Swig_var_MILLISECONDS_IN_TIMESTAMP_set);
  SWIG_addvarlink(globals, "TIMESTAMP_PRECISION", Swig_var_TIMESTAMP_PRECISION_get, Swig_var_TIMESTAMP_PRECISION_set);
  SWIG_addvarlink(globals, "HTTP_ACCEPT_PORT", Swig_var_HTTP_ACCEPT_PORT_get, Swig_var_HTTP_ACCEPT_PORT_set);
  SWIG_addvarlink(globals, "PERSIST_MESSAGES", Swig_var_PERSIST_MESSAGES_get, Swig_var_PERSIST_MESSAGES_set);
  SWIG_addvarlink(globals, "SERVER_CERTIFICATE_FILE", Swig_var_SERVER_CERTIFICATE_FILE_get, Swig_var_SERVER_CERTIFICATE_FILE_set);
  SWIG_addvarlink(globals, "SERVER_CERTIFICATE_KEY_FILE", Swig_var_SERVER_CERTIFICATE_KEY_FILE_get, Swig_var_SERVER_CERTIFICATE_KEY_FILE_set);
  SWIG_addvarlink(globals, "CLIENT_CERTIFICATE_FILE", Swig_var_CLIENT_CERTIFICATE_FILE_get, Swig_var_CLIENT_CERTIFICATE_FILE_set);
  SWIG_addvarlink(globals, "CLIENT_CERTIFICATE_KEY_FILE", Swig_var_CLIENT_CERTIFICATE_KEY_FILE_get, Swig_var_CLIENT_CERTIFICATE_KEY_FILE_set);
  SWIG_addvarlink(globals, "CERTIFICATE_AUTHORITIES_FILE", Swig_var_CERTIFICATE_AUTHORITIES_FILE_get, Swig_var_CERTIFICATE_AUTHORITIES_FILE_set);
  SWIG_addvarlink(globals, "CERTIFICATE_AUTHORITIES_DIRECTORY", Swig_var_CERTIFICATE_AUTHORITIES_DIRECTORY_get, Swig_var_CERTIFICATE_AUTHORITIES_DIRECTORY_set);
  SWIG_addvarlink(globals, "CERTIFICATE_REVOCATION_LIST_FILE", Swig_var_CERTIFICATE_REVOCATION_LIST_FILE_get, Swig_var_CERTIFICATE_REVOCATION_LIST_FILE_set);
  SWIG_addvarlink(globals, "CERTIFICATE_REVOCATION_LIST_DIRECTORY", Swig_var_CERTIFICATE_REVOCATION_LIST_DIRECTORY_get, Swig_var_CERTIFICATE_REVOCATION_LIST_DIRECTORY_set);
  SWIG_addvarlink(globals, "CERTIFICATE_VERIFY_LEVEL", Swig_var_CERTIFICATE_VERIFY_LEVEL_get, Swig_var_CERTIFICATE_VERIFY_LEVEL_set);
  SWIG_addvarlink(globals, "ALLOWED_REMOTE_ADDRESSES", Swig_var_ALLOWED_REMOTE_ADDRESSES_get, Swig_var_ALLOWED_REMOTE_ADDRESSES_set);
  SWIG_addvarlink(globals, "SSL_PROTOCOL", Swig_var_SSL_PROTOCOL_get, Swig_var_SSL_PROTOCOL_set);
  SWIG_addvarlink(globals, "SSL_CIPHER_SUITE", Swig_var_SSL_CIPHER_SUITE_get, Swig_var_SSL_CIPHER_SUITE_set);
  SWIG_addvarlink(globals, "TLS_CIPHER_SUITES", Swig_var_TLS_CIPHER_SUITES_get, Swig_var_TLS_CIPHER_SUITES_set);
  SWIG_addvarlink(globals, "MySQLStoreFactory_DEFAULT_DATABASE", Swig_var_MySQLStoreFactory_DEFAULT_DATABASE_get, Swig_var_MySQLStoreFactory_DEFAULT_DATABASE_set);
  SWIG_addvarlink(globals, "MySQLStoreFactory_DEFAULT_USER", Swig_var_MySQLStoreFactory_DEFAULT_USER_get, Swig_var_MySQLStoreFactory_DEFAULT_USER_set);
  SWIG_addvarlink(globals, "MySQLStoreFactory_DEFAULT_PASSWORD", Swig_var_MySQLStoreFactory_DEFAULT_PASSWORD_get, Swig_var_MySQLStoreFactory_DEFAULT_PASSWORD_set);
  SWIG_addvarlink(globals, "MySQLStoreFactory_DEFAULT_HOST", Swig_var_MySQLStoreFactory_DEFAULT_HOST_get, Swig_var_MySQLStoreFactory_DEFAULT_HOST_set);
  SWIG_addvarlink(globals, "MySQLStoreFactory_DEFAULT_PORT", Swig_var_MySQLStoreFactory_DEFAULT_PORT_get, Swig_var_MySQLStoreFactory_DEFAULT_PORT_set);
  SWIG_addvarlink(globals, "MySQLLogFactory_DEFAULT_DATABASE", Swig_var_MySQLLogFactory_DEFAULT_DATABASE_get, Swig_var_MySQLLogFactory_DEFAULT_DATABASE_set);
  SWIG_addvarlink(globals, "MySQLLogFactory_DEFAULT_USER", Swig_var_MySQLLogFactory_DEFAULT_USER_get, Swig_var_MySQLLogFactory_DEFAULT_USER_set);
  SWIG_addvarlink(globals, "MySQLLogFactory_DEFAULT_PASSWORD", Swig_var_MySQLLogFactory_DEFAULT_PASSWORD_get, Swig_var_MySQLLogFactory_DEFAULT_PASSWORD_set);
  SWIG_addvarlink(globals, "MySQLLogFactory_DEFAULT_HOST", Swig_var_MySQLLogFactory_DEFAULT_HOST_get, Swig_var_MySQLLogFactory_DEFAULT_HOST_set);
  SWIG_addvarlink(globals, "MySQLLogFactory_DEFAULT_PORT", Swig_var_MySQLLogFactory_DEFAULT_PORT_get, Swig_var_MySQLLogFactory_DEFAULT_PORT_set);
  SWIG_addvarlink(globals, "PostgreSQLStoreFactory_DEFAULT_DATABASE", Swig_var_PostgreSQLStoreFactory_DEFAULT_DATABASE_get, Swig_var_PostgreSQLStoreFactory_DEFAULT_DATABASE_set);
  SWIG_addvarlink(globals, "PostgreSQLStoreFactory_DEFAULT_USER", Swig_var_PostgreSQLStoreFactory_DEFAULT_USER_get, Swig_var_PostgreSQLStoreFactory_DEFAULT_USER_set);
  SWIG_addvarlink(globals, "PostgreSQLStoreFactory_DEFAULT_PASSWORD", Swig_var_PostgreSQLStoreFactory_DEFAULT_PASSWORD_get, Swig_var_PostgreSQLStoreFactory_DEFAULT_PASSWORD_set);
  SWIG_addvarlink(globals, "PostgreSQLStoreFactory_DEFAULT_HOST", Swig_var_PostgreSQLStoreFactory_DEFAULT_HOST_get, Swig_var_PostgreSQLStoreFactory_DEFAULT_HOST_set);
  SWIG_addvarlink(globals, "PostgreSQLStoreFactory_DEFAULT_PORT", Swig_var_PostgreSQLStoreFactory_DEFAULT_PORT_get, Swig_var_PostgreSQLStoreFactory_DEFAULT_PORT_set);
  SWIG_addvarlink(globals, "PostgreSQLLogFactory_DEFAULT_DATABASE", Swig_var_PostgreSQLLogFactory_DEFAULT_DATABASE_get, Swig_var_PostgreSQLLogFactory_DEFAULT_DATABASE_set);
  SWIG_addvarlink(globals, "PostgreSQLLogFactory_DEFAULT_USER", Swig_var_PostgreSQLLogFactory_DEFAULT_USER_get, Swig_var_PostgreSQLLogFactory_DEFAULT_USER_set);
  SWIG_addvarlink(globals, "PostgreSQLLogFactory_DEFAULT_PASSWORD", Swig_var_PostgreSQLLogFactory_DEFAULT_PASSWORD_get, Swig_var_PostgreSQLLogFactory_DEFAULT_PASSWORD_set);
  SWIG_addvarlink(globals, "PostgreSQLLogFactory_DEFAULT_HOST", Swig_var_PostgreSQLLogFactory_DEFAULT_HOST_get, Swig_var_PostgreSQLLogFactory_DEFAULT_HOST_set);
  SWIG_addvarlink(globals, "PostgreSQLLogFactory_DEFAULT_PORT", Swig_var_PostgreSQLLogFactory_DEFAULT_PORT_get, Swig_var_PostgreSQLLogFactory_DEFAULT_PORT_set);
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

